Running ‘000.sessionDetails.R’ [9s/12s]
  Running ‘ClusterRegistry.R’ [1s/122s]
  Running ‘Future-class.R’ [1s/123s]
  Running ‘FutureError.R’
  Running ‘FutureGlobals.R’
  Running ‘FutureRegistry.R’
  Running ‘as.cluster.R’ [1s/122s]
  Running ‘availableCores.R’
  Running ‘availableWorkers.R’
  Running ‘backtrace.R’
  Running ‘cluster-missing-future-pkg.R’
  Running ‘cluster.R’ [2s/124s]
  Running ‘constant.R’
  Running ‘demo.R’ [11s/132s]
  Running ‘dotdotdot.R’ [2s/123s]
  Running ‘early-signaling.R’ [1s/122s]
  Running ‘future,labels.R’
  Running ‘future.R’
  Running ‘futureAssign.R’ [2s/126s]
  Running ‘futureAssign_OP.R’ [3s/126s]
  Running ‘futureAssign_OP_with_environment.R’
  Running ‘futureAssign_OP_with_listenv.R’
  Running ‘futureCall.R’ [3s/124s]
  Running ‘futureOf.R’
  Running ‘futureOf_with_environment.R’
  Running ‘futureOf_with_listenv.R’
  Running ‘futures.R’ [1s/122s]
  Running ‘globals,NSE.R’
  Running ‘globals,formulas.R’ [2s/122s]
  Running ‘globals,manual.R’
  Running ‘globals,resolve.R’ [1s/121s]
  Running ‘globals,subassignment.R’ [2s/122s]
  Running ‘globals,toolarge.R’ [1s/121s]
  Running ‘globals,tricky.R’ [4s/124s]
  Running ‘globals,tricky_recursive.R’
  Running ‘globalsOf,tweaks.R’
  Running ‘immediateCondition.R’
  Running ‘invalid-owner.R’ [1s/121s]
  Running ‘makeClusterPSOCK.R’ [1s/121s]
  Running ‘mandelbrot.R’
  Running ‘mpi.R’
  Running ‘multicore,multithreading.R’
  Running ‘multicore.R’
  Running ‘multiprocess.R’
  Running ‘multisession.R’ [1s/121s]
  Running ‘nbrOfWorkers.R’ [1s/121s]
  Running ‘nested_futures,mc.cores.R’ [1s/121s]
  Running ‘nested_futures.R’
  Running ‘non-exportable,connections.R’ [1s/121s]
  Running ‘objectSize.R’
  Running ‘plan.R’ [1s/121s]
  Running ‘relaying.R’
  Running ‘remote.R’ [1s/121s]
  Running ‘requestCore.R’
  Running ‘requestNode.R’ [1s/121s]
  Running ‘reserved-keyword-functions.R’
  Running ‘resolve.R’
  Running ‘resolved-non-blocking-test.R’ [1s/127s]
  Running ‘rng.R’ [6s/126s]
  Running ‘sequential.R’
  Running ‘sessionDetails.R’
  Running ‘startup.R’ [1s/121s]
  Running ‘stdout.R’ [1s/122s]
  Running ‘transparent.R’
  Running ‘tweak.R’
  Running ‘utils.R’
  Running ‘uuid.R’
  Running ‘whichIndex.R’
Running the tests in ‘tests/ClusterRegistry.R’ failed.
Complete output:
  > source("incl/start.R")
  [02:51:56.403] plan(): Setting new future strategy stack:
  [02:51:56.405] List of future strategies:
  [02:51:56.405] 1. sequential:
  [02:51:56.405]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [02:51:56.405]    - tweaked: FALSE
  [02:51:56.405]    - call: future::plan("sequential")
  [02:51:56.408] plan(): nbrOfWorkers() = 1
  > 
  > message("*** ClusterRegistry() ... ")
  *** ClusterRegistry() ... 
  > 
  > allCores <- 1:availCores
  > 
  > ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
  > if (isWin32) allCores <- NULL
  > 
  > for (cores in allCores) {
  +   message(sprintf("Testing with %d cores ...", cores))
  +   options(mc.cores = cores)
  + 
  +   message("Available cores: ", availableCores())
  + 
  +   ## In case sessions have been created in previous tests
  +   message("Stopping any running cluster ...")
  +   ClusterRegistry("stop")
  +   cluster <- ClusterRegistry("get")
  +   stopifnot(length(cluster) == 0)
  +   message("Stopping any running cluster ... DONE")
  + 
  +   message("Starting cluster ...")
  +   res <- tryCatch({
  +     cluster <- ClusterRegistry("set", workers = availableCores() - 1L)
  +     str(cluster)
  +     print(cluster)
  +   }, error = identity)
  +   if (cores == 1) stopifnot(inherits(res, "error"))
  +   message("Starting cluster ... DONE")
  + 
  +   message("Starting dual-worker cluster ...")
  +   cluster <- ClusterRegistry(action = "start", workers = 2L)
  +   str(cluster)
  +   print(cluster)
  +   stopifnot(length(cluster) == 2L)
  +   message("Starting duel-worker cluster ... DONE")
  +   
  +   message("Starting single-worker cluster ...")
  +   cluster <- ClusterRegistry(action = "start", workers = 1L)
  +   str(cluster)
  +   print(cluster)
  +   stopifnot(length(cluster) == 1L)
  +   message("Starting single-worker cluster ... DONE")
  + 
  +   cluster <- ClusterRegistry(action = "get")
  +   print(cluster)
  +   stopifnot(length(cluster) == 1L)
  + 
  +   message("Stopping single-worker cluster ...")
  +   cluster <- ClusterRegistry(action = "stop")
  +   print(cluster)
  +   stopifnot(length(cluster) == 0L)
  +   message("Stopping single-worker cluster ... DONE")
  + 
  +   message(sprintf("Testing with %d cores ... DONE", cores))
  + } ## for (cores ...)
  Testing with 1 cores ...
  Available cores: 1
  Stopping any running cluster ...
  Stopping any running cluster ... DONE
  Starting cluster ...
  Starting cluster ... DONE
  Starting dual-worker cluster ...
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 27563
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/data/gannet/ripley/R/R-devel/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/RtmpVN49yr/future.parent=4163195.3f867b1fa1667a.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpxHETCY/working_dir/RtmpVN49yr/future.parent=4163195.3f867b1fa1667a.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/ClusterRegistry.R:gannet.stats.ox.ac.uk:ripley:4163195' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/RtmpVN49yr/future.parent=4163195.3f867b1fa1667a.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=27563 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  Error in get(name, envir = asNamespace(pkg), inherits = FALSE) : 
    object '.slaveRSOCK' not found
  Calls: ::: -> get
  Execution halted
  Killing worker process (PID 4163400) if still alive
  [02:53:57.657] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(4163195, signal = 0L)
  [1] TRUE
  Call: tools::pskill(4163195, signal = 0L)
  [1] TRUE
  [02:53:57.659] - success
  [02:53:57.659] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 4163400) was successfully killed: TRUE
  Error in makeRestartList(...) : 
    Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gannet.stats.ox.ac.uk'.
   * The error produced by socketConnection() was: 'reached elapsed time limit' (which suggests that the connection timeout of 120 seconds (argument 'connectTimeout') kicked in)
   * The localhost socket connection that failed to connect to the R worker used port 27563 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/ClusterRegistry.R:gannet.stats.ox.ac.uk:ripley:4163195' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/RtmpVN49yr/future.parent=4163195.3f867b1fa1667a.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=27563 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 4163400) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: ClusterRegistry ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted
Running the tests in ‘tests/Future-class.R’ failed.
Complete output:
  > source("incl/start.R")
  [02:53:58.585] plan(): Setting new future strategy stack:
  [02:53:58.587] List of future strategies:
  [02:53:58.587] 1. sequential:
  [02:53:58.587]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [02:53:58.587]    - tweaked: FALSE
  [02:53:58.587]    - call: future::plan("sequential")
  [02:53:58.590] plan(): nbrOfWorkers() = 1
  > 
  > message("*** Future class ...")
  *** Future class ...
  > 
  > message("*** Future class - exception ...")
  *** Future class - exception ...
  > 
  > f <- Future()
  > print(f)
  Future:
  Label: '<none>'
  Expression:
  NULL
  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: 61ca42c1-aeea-7981-2191-49ac4c6378be
  Class: 'Future', 'environment'
  > res <- tryCatch(value(f), error = identity)
  > print(res)
  <simpleError: C stack usage  19926836 is too close to the limit>
  > stopifnot(inherits(res, "error"))
  > 
  > ## values() is an alias for value() for Future
  > res <- tryCatch(values(f), error = identity)
  > stopifnot(inherits(res, "error"))
  > 
  > ## Invalid seed
  > res <- tryCatch(f <- Future(42, seed = 1:2), error = identity)
  > stopifnot(inherits(res, "error"))
  > 
  > ## When no packages are exported
  > foo <- structure(function(...) { Future(1) }, class = "future")
  > plan(foo)
  [02:53:58.768] plan(): Setting new future strategy stack:
  [02:53:58.768] List of future strategies:
  [02:53:58.768] 1. future:
  [02:53:58.768]    - args: function (...)
  [02:53:58.768]    - tweaked: FALSE
  [02:53:58.768]    - call: plan(foo)
  [02:53:58.829] plan(): nbrOfWorkers() = Inf
  > f <- Future()
  > expr <- getExpression(f)
  [02:53:58.832] Packages needed by the future expression (n = 0): <none>
  [02:53:58.833] Packages needed by future strategies (n = 0): <none>
  [02:53:58.841] {
  [02:53:58.841]     {
  [02:53:58.841]         ...future.startTime <- base::Sys.time()
  [02:53:58.841]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [02:53:58.841]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [02:53:58.841]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [02:53:58.841]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [02:53:58.841]             future.resolve.recursive = NULL, width = 80L)
  [02:53:58.841]         {
  [02:53:58.841]             {
  [02:53:58.841]                 base::local({
  [02:53:58.841]                   has_future <- base::requireNamespace("future", 
  [02:53:58.841]                     quietly = TRUE)
  [02:53:58.841]                   version <- if (has_future) 
  [02:53:58.841]                     utils::packageVersion("future")
  [02:53:58.841]                   else NULL
  [02:53:58.841]                   if (!has_future || version < "1.8.0") {
  [02:53:58.841]                     info <- base::c(r_version = base::gsub("R version ", 
  [02:53:58.841]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [02:53:58.841]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [02:53:58.841]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [02:53:58.841]                         "release", "version")], collapse = " "), 
  [02:53:58.841]                       hostname = base::Sys.info()[["nodename"]])
  [02:53:58.841]                     info <- base::sprintf("%s: %s", base::names(info), 
  [02:53:58.841]                       info)
  [02:53:58.841]                     info <- base::paste(info, collapse = "; ")
  [02:53:58.841]                     if (!has_future) {
  [02:53:58.841]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [02:53:58.841]                         info)
  [02:53:58.841]                     }
  [02:53:58.841]                     else {
  [02:53:58.841]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [02:53:58.841]                         info, version)
  [02:53:58.841]                     }
  [02:53:58.841]                     base::stop(msg)
  [02:53:58.841]                   }
  [02:53:58.841]                 })
  [02:53:58.841]             }
  [02:53:58.841]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [02:53:58.841]         }
  [02:53:58.841]     }
  [02:53:58.841]     if (base::is.na(TRUE)) {
  [02:53:58.841]     }
  [02:53:58.841]     else {
  [02:53:58.841]         if (TRUE) {
  [02:53:58.841]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [02:53:58.841]                 open = "w")
  [02:53:58.841]         }
  [02:53:58.841]         else {
  [02:53:58.841]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [02:53:58.841]                 windows = "NUL", "/dev/null"), open = "w")
  [02:53:58.841]         }
  [02:53:58.841]         base::sink(...future.stdout, type = "output", split = FALSE)
  [02:53:58.841]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [02:53:58.841]             base::sink(type = "output", split = FALSE)
  [02:53:58.841]             base::close(...future.stdout)
  [02:53:58.841]         }, add = TRUE)
  [02:53:58.841]     }
  [02:53:58.841]     ...future.frame <- base::sys.nframe()
  [02:53:58.841]     ...future.conditions <- base::list()
  [02:53:58.841]     ...future.rng <- base::globalenv()$.Random.seed
  [02:53:58.841]     ...future.result <- base::tryCatch({
  [02:53:58.841]         base::withCallingHandlers({
  [02:53:58.841]             ...future.value <- base::withVisible(base::local(NULL))
  [02:53:58.841]             future::FutureResult(value = ...future.value$value, 
  [02:53:58.841]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [02:53:58.841]                   ...future.rng), started = ...future.startTime, 
  [02:53:58.841]                 version = "1.8")
  [02:53:58.841]         }, condition = base::local({
  [02:53:58.841]             c <- base::c
  [02:53:58.841]             inherits <- base::inherits
  [02:53:58.841]             invokeRestart <- base::invokeRestart
  [02:53:58.841]             length <- base::length
  [02:53:58.841]             list <- base::list
  [02:53:58.841]             seq.int <- base::seq.int
  [02:53:58.841]             signalCondition <- base::signalCondition
  [02:53:58.841]             sys.calls <- base::sys.calls
  [02:53:58.841]             Sys.time <- base::Sys.time
  [02:53:58.841]             `[[` <- base::`[[`
  [02:53:58.841]             `+` <- base::`+`
  [02:53:58.841]             `<<-` <- base::`<<-`
  [02:53:58.841]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [02:53:58.841]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [02:53:58.841]                   3L)]
  [02:53:58.841]             }
  [02:53:58.841]             function(cond) {
  [02:53:58.841]                 if (inherits(cond, "error")) {
  [02:53:58.841]                   sessionInformation <- function() {
  [02:53:58.841]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [02:53:58.841]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [02:53:58.841]                       search = base::search(), system = base::Sys.info())
  [02:53:58.841]                   }
  [02:53:58.841]                   ...future.conditions[[length(...future.conditions) + 
  [02:53:58.841]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [02:53:58.841]                     cond$call), session = sessionInformation(), 
  [02:53:58.841]                     timestamp = Sys.time(), signaled = 0L)
  [02:53:58.841]                   signalCondition(cond)
  [02:53:58.841]                 }
  [02:53:58.841]                 else if (inherits(cond, "condition")) {
  [02:53:58.841]                   signal <- FALSE && inherits(cond, character(0))
  [02:53:58.841]                   ...future.conditions[[length(...future.conditions) + 
  [02:53:58.841]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [02:53:58.841]                   if (!signal) {
  [02:53:58.841]                     muffleCondition <- function (cond) 
  [02:53:58.841]                     {
  [02:53:58.841]                       inherits <- base::inherits
  [02:53:58.841]                       invokeRestart <- base::invokeRestart
  [02:53:58.841]                       muffled <- FALSE
  [02:53:58.841]                       if (inherits(cond, "message")) {
  [02:53:58.841]                         invokeRestart("muffleMessage")
  [02:53:58.841]                         muffled <- TRUE
  [02:53:58.841]                       }
  [02:53:58.841]                       else if (inherits(cond, "warning")) {
  [02:53:58.841]                         invokeRestart("muffleWarning")
  [02:53:58.841]                         muffled <- TRUE
  [02:53:58.841]                       }
  [02:53:58.841]                       else if (inherits(cond, "condition")) {
  [02:53:58.841]                         computeRestarts <- base::computeRestarts
  [02:53:58.841]                         grepl <- base::grepl
  [02:53:58.841]                         is.null <- base::is.null
  [02:53:58.841]                         restarts <- computeRestarts(cond)
  [02:53:58.841]                         for (restart in restarts) {
  [02:53:58.841]                           name <- restart$name
  [02:53:58.841]                           if (is.null(name)) 
  [02:53:58.841]                             next
  [02:53:58.841]                           if (!grepl("^muffle", name)) 
  [02:53:58.841]                             next
  [02:53:58.841]                           invokeRestart(restart)
  [02:53:58.841]                           muffled <- TRUE
  [02:53:58.841]                           break
  [02:53:58.841]                         }
  [02:53:58.841]                       }
  [02:53:58.841]                       invisible(muffled)
  [02:53:58.841]                     }
  [02:53:58.841]                     muffleCondition(cond)
  [02:53:58.841]                   }
  [02:53:58.841]                 }
  [02:53:58.841]             }
  [02:53:58.841]         }))
  [02:53:58.841]     }, error = function(ex) {
  [02:53:58.841]         base::structure(base::list(value = NULL, visible = NULL, 
  [02:53:58.841]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [02:53:58.841]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [02:53:58.841]     }, finally = {
  [02:53:58.841]         {
  [02:53:58.841]             NULL
  [02:53:58.841]             future::plan(list(function (...) 
  [02:53:58.841]             {
  [02:53:58.841]                 Future(1)
  [02:53:58.841]             }), .cleanup = FALSE, .init = FALSE)
  [02:53:58.841]         }
  [02:53:58.841]         base::options(...future.oldOptions)
  [02:53:58.841]     })
  [02:53:58.841]     Sys.time
  [02:53:58.841]     if (base::is.na(TRUE)) {
  [02:53:58.841]     }
  [02:53:58.841]     else {
  [02:53:58.841]         base::sink(type = "output", split = FALSE)
  [02:53:58.841]         if (TRUE) {
  [02:53:58.841]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [02:53:58.841]         }
  [02:53:58.841]         else {
  [02:53:58.841]             ...future.result["stdout"] <- base::list(NULL)
  [02:53:58.841]         }
  [02:53:58.841]         base::close(...future.stdout)
  [02:53:58.841]         ...future.stdout <- NULL
  [02:53:58.841]     }
  [02:53:58.841]     ...future.result$conditions <- ...future.conditions
  [02:53:58.841]     ...future.result
  [02:53:58.841] }
  > print(expr)
  {
      {
          ...future.startTime <- base::Sys.time()
          ...future.oldOptions <- base::options(future.startup.script = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = NULL, 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  base::local({
                    has_future <- base::requireNamespace("future", 
                      quietly = TRUE)
                    version <- if (has_future) 
                      utils::packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- base::c(r_version = base::gsub("R version ", 
                        "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
                        base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
                        os = base::paste(base::Sys.info()[base::c("sysname", 
                          "release", "version")], collapse = " "), 
                        hostname = base::Sys.info()[["nodename"]])
                      info <- base::sprintf("%s: %s", base::names(info), 
                        info)
                      info <- base::paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      base::stop(msg)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (base::is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- base::rawConnection(base::raw(0L), 
                  open = "w")
          }
          else {
              ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          base::sink(...future.stdout, type = "output", split = FALSE)
          base::on.exit(if (!base::is.null(...future.stdout)) {
              base::sink(type = "output", split = FALSE)
              base::close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- base::sys.nframe()
      ...future.conditions <- base::list()
      ...future.rng <- base::globalenv()$.Random.seed
      ...future.result <- base::tryCatch({
          base::withCallingHandlers({
              ...future.value <- base::withVisible(base::local(NULL))
              future::FutureResult(value = ...future.value$value, 
                  visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
                    ...future.rng), started = ...future.startTime, 
                  version = "1.8")
          }, condition = base::local({
              c <- base::c
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              list <- base::list
              seq.int <- base::seq.int
              signalCondition <- base::signalCondition
              sys.calls <- base::sys.calls
              Sys.time <- base::Sys.time
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    sessionInformation <- function() {
                      list(r = base::R.Version(), locale = base::Sys.getlocale(), 
                        rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
                        search = base::search(), system = base::Sys.info())
                    }
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), session = sessionInformation(), 
                      timestamp = Sys.time(), signaled = 0L)
                    signalCondition(cond)
                  }
                  else if (inherits(cond, "condition")) {
                    signal <- FALSE && inherits(cond, character(0))
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
                    if (!signal) {
                      muffleCondition <- function (cond) 
                      {
                        inherits <- base::inherits
                        invokeRestart <- base::invokeRestart
                        muffled <- FALSE
                        if (inherits(cond, "message")) {
                          invokeRestart("muffleMessage")
                          muffled <- TRUE
                        }
                        else if (inherits(cond, "warning")) {
                          invokeRestart("muffleWarning")
                          muffled <- TRUE
                        }
                        else if (inherits(cond, "condition")) {
                          computeRestarts <- base::computeRestarts
                          grepl <- base::grepl
                          is.null <- base::is.null
                          restarts <- computeRestarts(cond)
                          for (restart in restarts) {
                            name <- restart$name
                            if (is.null(name)) 
                              next
                            if (!grepl("^muffle", name)) 
                              next
                            invokeRestart(restart)
                            muffled <- TRUE
                            break
                          }
                        }
                        invisible(muffled)
                      }
                      muffleCondition(cond)
                    }
                  }
              }
          }))
      }, error = function(ex) {
          base::structure(base::list(value = NULL, visible = NULL, 
              conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
                  ...future.rng), version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              NULL
              future::plan(list(function (...) 
              {
                  Future(1)
              }), .cleanup = FALSE, .init = FALSE)
          }
          base::options(...future.oldOptions)
      })
      Sys.time
      if (base::is.na(TRUE)) {
      }
      else {
          base::sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- base::list(NULL)
          }
          base::close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  > stopifnot(is.call(expr))
  > 
  > clazzes <- list(
  +   sequential = SequentialFuture,
  +   multisession = function(...) MultisessionFuture(..., workers = 2L),
  +   sequential = SequentialFuture
  + )
  > if (supportsMulticore()) {
  +   clazzes$multicore = function(...) MulticoreFuture(..., workers = 2L)
  + }
  > 
  > for (clazz in clazzes) {
  +   ## Calling run() more than once
  +   f <- clazz({ 42L })
  +   print(f)
  +   run(f)
  +   res <- tryCatch(run(f), error = identity)
  +   stopifnot(inherits(res, "error"))
  +   v <- value(f)
  +   print(v)
  +   stopifnot(v == 42L)
  + 
  +   ## Call value() without run()
  +   f <- clazz({ 42L })
  +   v <- value(f)
  +   print(v)
  +   stopifnot(v == 42L)
  + }
  [02:53:58.879] getGlobalsAndPackages() ...
  [02:53:58.879] Searching for globals...
  [02:53:58.885] 
  [02:53:58.885] Searching for globals ... DONE
  [02:53:58.886] - globals: [0] <none>
  [02:53:58.886] getGlobalsAndPackages() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  [1] 42
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  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: 61ca42c1-aeea-7981-2191-49ac4c6378be
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [02:53:58.891] Packages needed by the future expression (n = 0): <none>
  [02:53:58.891] Packages needed by future strategies (n = 0): <none>
  [02:53:58.898] {
  [02:53:58.898]     {
  [02:53:58.898]         ...future.startTime <- base::Sys.time()
  [02:53:58.898]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [02:53:58.898]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [02:53:58.898]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [02:53:58.898]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [02:53:58.898]             future.resolve.recursive = NULL, width = 80L)
  [02:53:58.898]         {
  [02:53:58.898]             {
  [02:53:58.898]                 base::local({
  [02:53:58.898]                   has_future <- base::requireNamespace("future", 
  [02:53:58.898]                     quietly = TRUE)
  [02:53:58.898]                   version <- if (has_future) 
  [02:53:58.898]                     utils::packageVersion("future")
  [02:53:58.898]                   else NULL
  [02:53:58.898]                   if (!has_future || version < "1.8.0") {
  [02:53:58.898]                     info <- base::c(r_version = base::gsub("R version ", 
  [02:53:58.898]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [02:53:58.898]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [02:53:58.898]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [02:53:58.898]                         "release", "version")], collapse = " "), 
  [02:53:58.898]                       hostname = base::Sys.info()[["nodename"]])
  [02:53:58.898]                     info <- base::sprintf("%s: %s", base::names(info), 
  [02:53:58.898]                       info)
  [02:53:58.898]                     info <- base::paste(info, collapse = "; ")
  [02:53:58.898]                     if (!has_future) {
  [02:53:58.898]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [02:53:58.898]                         info)
  [02:53:58.898]                     }
  [02:53:58.898]                     else {
  [02:53:58.898]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [02:53:58.898]                         info, version)
  [02:53:58.898]                     }
  [02:53:58.898]                     base::stop(msg)
  [02:53:58.898]                   }
  [02:53:58.898]                 })
  [02:53:58.898]             }
  [02:53:58.898]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [02:53:58.898]         }
  [02:53:58.898]     }
  [02:53:58.898]     if (base::is.na(TRUE)) {
  [02:53:58.898]     }
  [02:53:58.898]     else {
  [02:53:58.898]         if (TRUE) {
  [02:53:58.898]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [02:53:58.898]                 open = "w")
  [02:53:58.898]         }
  [02:53:58.898]         else {
  [02:53:58.898]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [02:53:58.898]                 windows = "NUL", "/dev/null"), open = "w")
  [02:53:58.898]         }
  [02:53:58.898]         base::sink(...future.stdout, type = "output", split = FALSE)
  [02:53:58.898]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [02:53:58.898]             base::sink(type = "output", split = FALSE)
  [02:53:58.898]             base::close(...future.stdout)
  [02:53:58.898]         }, add = TRUE)
  [02:53:58.898]     }
  [02:53:58.898]     ...future.frame <- base::sys.nframe()
  [02:53:58.898]     ...future.conditions <- base::list()
  [02:53:58.898]     ...future.rng <- base::globalenv()$.Random.seed
  [02:53:58.898]     ...future.result <- base::tryCatch({
  [02:53:58.898]         base::withCallingHandlers({
  [02:53:58.898]             ...future.value <- base::withVisible(base::local(42L))
  [02:53:58.898]             future::FutureResult(value = ...future.value$value, 
  [02:53:58.898]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [02:53:58.898]                   ...future.rng), started = ...future.startTime, 
  [02:53:58.898]                 version = "1.8")
  [02:53:58.898]         }, condition = base::local({
  [02:53:58.898]             c <- base::c
  [02:53:58.898]             inherits <- base::inherits
  [02:53:58.898]             invokeRestart <- base::invokeRestart
  [02:53:58.898]             length <- base::length
  [02:53:58.898]             list <- base::list
  [02:53:58.898]             seq.int <- base::seq.int
  [02:53:58.898]             signalCondition <- base::signalCondition
  [02:53:58.898]             sys.calls <- base::sys.calls
  [02:53:58.898]             Sys.time <- base::Sys.time
  [02:53:58.898]             `[[` <- base::`[[`
  [02:53:58.898]             `+` <- base::`+`
  [02:53:58.898]             `<<-` <- base::`<<-`
  [02:53:58.898]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [02:53:58.898]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [02:53:58.898]                   3L)]
  [02:53:58.898]             }
  [02:53:58.898]             function(cond) {
  [02:53:58.898]                 if (inherits(cond, "error")) {
  [02:53:58.898]                   sessionInformation <- function() {
  [02:53:58.898]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [02:53:58.898]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [02:53:58.898]                       search = base::search(), system = base::Sys.info())
  [02:53:58.898]                   }
  [02:53:58.898]                   ...future.conditions[[length(...future.conditions) + 
  [02:53:58.898]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [02:53:58.898]                     cond$call), session = sessionInformation(), 
  [02:53:58.898]                     timestamp = Sys.time(), signaled = 0L)
  [02:53:58.898]                   signalCondition(cond)
  [02:53:58.898]                 }
  [02:53:58.898]                 else if (inherits(cond, c("condition", "immediateCondition"
  [02:53:58.898]                 ))) {
  [02:53:58.898]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [02:53:58.898]                   ...future.conditions[[length(...future.conditions) + 
  [02:53:58.898]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [02:53:58.898]                   if (!signal) {
  [02:53:58.898]                     muffleCondition <- function (cond) 
  [02:53:58.898]                     {
  [02:53:58.898]                       inherits <- base::inherits
  [02:53:58.898]                       invokeRestart <- base::invokeRestart
  [02:53:58.898]                       muffled <- FALSE
  [02:53:58.898]                       if (inherits(cond, "message")) {
  [02:53:58.898]                         invokeRestart("muffleMessage")
  [02:53:58.898]                         muffled <- TRUE
  [02:53:58.898]                       }
  [02:53:58.898]                       else if (inherits(cond, "warning")) {
  [02:53:58.898]                         invokeRestart("muffleWarning")
  [02:53:58.898]                         muffled <- TRUE
  [02:53:58.898]                       }
  [02:53:58.898]                       else if (inherits(cond, "condition")) {
  [02:53:58.898]                         computeRestarts <- base::computeRestarts
  [02:53:58.898]                         grepl <- base::grepl
  [02:53:58.898]                         is.null <- base::is.null
  [02:53:58.898]                         restarts <- computeRestarts(cond)
  [02:53:58.898]                         for (restart in restarts) {
  [02:53:58.898]                           name <- restart$name
  [02:53:58.898]                           if (is.null(name)) 
  [02:53:58.898]                             next
  [02:53:58.898]                           if (!grepl("^muffle", name)) 
  [02:53:58.898]                             next
  [02:53:58.898]                           invokeRestart(restart)
  [02:53:58.898]                           muffled <- TRUE
  [02:53:58.898]                           break
  [02:53:58.898]                         }
  [02:53:58.898]                       }
  [02:53:58.898]                       invisible(muffled)
  [02:53:58.898]                     }
  [02:53:58.898]                     muffleCondition(cond)
  [02:53:58.898]                   }
  [02:53:58.898]                 }
  [02:53:58.898]             }
  [02:53:58.898]         }))
  [02:53:58.898]     }, error = function(ex) {
  [02:53:58.898]         base::structure(base::list(value = NULL, visible = NULL, 
  [02:53:58.898]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [02:53:58.898]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [02:53:58.898]     }, finally = {
  [02:53:58.898]         {
  [02:53:58.898]             NULL
  [02:53:58.898]             future::plan(list(function (...) 
  [02:53:58.898]             {
  [02:53:58.898]                 Future(1)
  [02:53:58.898]             }), .cleanup = FALSE, .init = FALSE)
  [02:53:58.898]         }
  [02:53:58.898]         base::options(...future.oldOptions)
  [02:53:58.898]     })
  [02:53:58.898]     Sys.time
  [02:53:58.898]     if (base::is.na(TRUE)) {
  [02:53:58.898]     }
  [02:53:58.898]     else {
  [02:53:58.898]         base::sink(type = "output", split = FALSE)
  [02:53:58.898]         if (TRUE) {
  [02:53:58.898]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [02:53:58.898]         }
  [02:53:58.898]         else {
  [02:53:58.898]             ...future.result["stdout"] <- base::list(NULL)
  [02:53:58.898]         }
  [02:53:58.898]         base::close(...future.stdout)
  [02:53:58.898]         ...future.stdout <- NULL
  [02:53:58.898]     }
  [02:53:58.898]     ...future.result$conditions <- ...future.conditions
  [02:53:58.898]     ...future.result
  [02:53:58.898] }
  [02:53:58.905] plan(): Setting new future strategy stack:
  [02:53:58.905] List of future strategies:
  [02:53:58.905] 1. sequential:
  [02:53:58.905]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [02:53:58.905]    - tweaked: FALSE
  [02:53:58.905]    - call: NULL
  [02:53:58.907] plan(): nbrOfWorkers() = 1
  [02:53:58.913] plan(): Setting new future strategy stack:
  [02:53:58.913] List of future strategies:
  [02:53:58.913] 1. future:
  [02:53:58.913]    - args: function (...)
  [02:53:58.913]    - tweaked: FALSE
  [02:53:58.913]    - call: plan(foo)
  [02:53:58.915] plan(): nbrOfWorkers() = Inf
  [02:53:58.915] SequentialFuture started (and completed)
  [1] 42
  [02:53:58.918] getGlobalsAndPackages() ...
  [02:53:58.918] Searching for globals...
  [02:53:58.919] 
  [02:53:58.919] Searching for globals ... DONE
  [02:53:58.920] - globals: [0] <none>
  [02:53:58.920] getGlobalsAndPackages() ... DONE
  [02:53:58.923] Packages needed by the future expression (n = 0): <none>
  [02:53:58.923] Packages needed by future strategies (n = 0): <none>
  [02:53:58.930] {
  [02:53:58.930]     {
  [02:53:58.930]         ...future.startTime <- base::Sys.time()
  [02:53:58.930]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [02:53:58.930]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [02:53:58.930]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [02:53:58.930]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [02:53:58.930]             future.resolve.recursive = NULL, width = 80L)
  [02:53:58.930]         {
  [02:53:58.930]             {
  [02:53:58.930]                 base::local({
  [02:53:58.930]                   has_future <- base::requireNamespace("future", 
  [02:53:58.930]                     quietly = TRUE)
  [02:53:58.930]                   version <- if (has_future) 
  [02:53:58.930]                     utils::packageVersion("future")
  [02:53:58.930]                   else NULL
  [02:53:58.930]                   if (!has_future || version < "1.8.0") {
  [02:53:58.930]                     info <- base::c(r_version = base::gsub("R version ", 
  [02:53:58.930]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [02:53:58.930]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [02:53:58.930]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [02:53:58.930]                         "release", "version")], collapse = " "), 
  [02:53:58.930]                       hostname = base::Sys.info()[["nodename"]])
  [02:53:58.930]                     info <- base::sprintf("%s: %s", base::names(info), 
  [02:53:58.930]                       info)
  [02:53:58.930]                     info <- base::paste(info, collapse = "; ")
  [02:53:58.930]                     if (!has_future) {
  [02:53:58.930]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [02:53:58.930]                         info)
  [02:53:58.930]                     }
  [02:53:58.930]                     else {
  [02:53:58.930]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [02:53:58.930]                         info, version)
  [02:53:58.930]                     }
  [02:53:58.930]                     base::stop(msg)
  [02:53:58.930]                   }
  [02:53:58.930]                 })
  [02:53:58.930]             }
  [02:53:58.930]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [02:53:58.930]         }
  [02:53:58.930]     }
  [02:53:58.930]     if (base::is.na(TRUE)) {
  [02:53:58.930]     }
  [02:53:58.930]     else {
  [02:53:58.930]         if (TRUE) {
  [02:53:58.930]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [02:53:58.930]                 open = "w")
  [02:53:58.930]         }
  [02:53:58.930]         else {
  [02:53:58.930]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [02:53:58.930]                 windows = "NUL", "/dev/null"), open = "w")
  [02:53:58.930]         }
  [02:53:58.930]         base::sink(...future.stdout, type = "output", split = FALSE)
  [02:53:58.930]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [02:53:58.930]             base::sink(type = "output", split = FALSE)
  [02:53:58.930]             base::close(...future.stdout)
  [02:53:58.930]         }, add = TRUE)
  [02:53:58.930]     }
  [02:53:58.930]     ...future.frame <- base::sys.nframe()
  [02:53:58.930]     ...future.conditions <- base::list()
  [02:53:58.930]     ...future.rng <- base::globalenv()$.Random.seed
  [02:53:58.930]     ...future.result <- base::tryCatch({
  [02:53:58.930]         base::withCallingHandlers({
  [02:53:58.930]             ...future.value <- base::withVisible(base::local(42L))
  [02:53:58.930]             future::FutureResult(value = ...future.value$value, 
  [02:53:58.930]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [02:53:58.930]                   ...future.rng), started = ...future.startTime, 
  [02:53:58.930]                 version = "1.8")
  [02:53:58.930]         }, condition = base::local({
  [02:53:58.930]             c <- base::c
  [02:53:58.930]             inherits <- base::inherits
  [02:53:58.930]             invokeRestart <- base::invokeRestart
  [02:53:58.930]             length <- base::length
  [02:53:58.930]             list <- base::list
  [02:53:58.930]             seq.int <- base::seq.int
  [02:53:58.930]             signalCondition <- base::signalCondition
  [02:53:58.930]             sys.calls <- base::sys.calls
  [02:53:58.930]             Sys.time <- base::Sys.time
  [02:53:58.930]             `[[` <- base::`[[`
  [02:53:58.930]             `+` <- base::`+`
  [02:53:58.930]             `<<-` <- base::`<<-`
  [02:53:58.930]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [02:53:58.930]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [02:53:58.930]                   3L)]
  [02:53:58.930]             }
  [02:53:58.930]             function(cond) {
  [02:53:58.930]                 if (inherits(cond, "error")) {
  [02:53:58.930]                   sessionInformation <- function() {
  [02:53:58.930]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [02:53:58.930]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [02:53:58.930]                       search = base::search(), system = base::Sys.info())
  [02:53:58.930]                   }
  [02:53:58.930]                   ...future.conditions[[length(...future.conditions) + 
  [02:53:58.930]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [02:53:58.930]                     cond$call), session = sessionInformation(), 
  [02:53:58.930]                     timestamp = Sys.time(), signaled = 0L)
  [02:53:58.930]                   signalCondition(cond)
  [02:53:58.930]                 }
  [02:53:58.930]                 else if (inherits(cond, c("condition", "immediateCondition"
  [02:53:58.930]                 ))) {
  [02:53:58.930]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [02:53:58.930]                   ...future.conditions[[length(...future.conditions) + 
  [02:53:58.930]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [02:53:58.930]                   if (!signal) {
  [02:53:58.930]                     muffleCondition <- function (cond) 
  [02:53:58.930]                     {
  [02:53:58.930]                       inherits <- base::inherits
  [02:53:58.930]                       invokeRestart <- base::invokeRestart
  [02:53:58.930]                       muffled <- FALSE
  [02:53:58.930]                       if (inherits(cond, "message")) {
  [02:53:58.930]                         invokeRestart("muffleMessage")
  [02:53:58.930]                         muffled <- TRUE
  [02:53:58.930]                       }
  [02:53:58.930]                       else if (inherits(cond, "warning")) {
  [02:53:58.930]                         invokeRestart("muffleWarning")
  [02:53:58.930]                         muffled <- TRUE
  [02:53:58.930]                       }
  [02:53:58.930]                       else if (inherits(cond, "condition")) {
  [02:53:58.930]                         computeRestarts <- base::computeRestarts
  [02:53:58.930]                         grepl <- base::grepl
  [02:53:58.930]                         is.null <- base::is.null
  [02:53:58.930]                         restarts <- computeRestarts(cond)
  [02:53:58.930]                         for (restart in restarts) {
  [02:53:58.930]                           name <- restart$name
  [02:53:58.930]                           if (is.null(name)) 
  [02:53:58.930]                             next
  [02:53:58.930]                           if (!grepl("^muffle", name)) 
  [02:53:58.930]                             next
  [02:53:58.930]                           invokeRestart(restart)
  [02:53:58.930]                           muffled <- TRUE
  [02:53:58.930]                           break
  [02:53:58.930]                         }
  [02:53:58.930]                       }
  [02:53:58.930]                       invisible(muffled)
  [02:53:58.930]                     }
  [02:53:58.930]                     muffleCondition(cond)
  [02:53:58.930]                   }
  [02:53:58.930]                 }
  [02:53:58.930]             }
  [02:53:58.930]         }))
  [02:53:58.930]     }, error = function(ex) {
  [02:53:58.930]         base::structure(base::list(value = NULL, visible = NULL, 
  [02:53:58.930]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [02:53:58.930]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [02:53:58.930]     }, finally = {
  [02:53:58.930]         {
  [02:53:58.930]             NULL
  [02:53:58.930]             future::plan(list(function (...) 
  [02:53:58.930]             {
  [02:53:58.930]                 Future(1)
  [02:53:58.930]             }), .cleanup = FALSE, .init = FALSE)
  [02:53:58.930]         }
  [02:53:58.930]         base::options(...future.oldOptions)
  [02:53:58.930]     })
  [02:53:58.930]     Sys.time
  [02:53:58.930]     if (base::is.na(TRUE)) {
  [02:53:58.930]     }
  [02:53:58.930]     else {
  [02:53:58.930]         base::sink(type = "output", split = FALSE)
  [02:53:58.930]         if (TRUE) {
  [02:53:58.930]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [02:53:58.930]         }
  [02:53:58.930]         else {
  [02:53:58.930]             ...future.result["stdout"] <- base::list(NULL)
  [02:53:58.930]         }
  [02:53:58.930]         base::close(...future.stdout)
  [02:53:58.930]         ...future.stdout <- NULL
  [02:53:58.930]     }
  [02:53:58.930]     ...future.result$conditions <- ...future.conditions
  [02:53:58.930]     ...future.result
  [02:53:58.930] }
  [02:53:58.937] plan(): Setting new future strategy stack:
  [02:53:58.937] List of future strategies:
  [02:53:58.937] 1. sequential:
  [02:53:58.937]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [02:53:58.937]    - tweaked: FALSE
  [02:53:58.937]    - call: NULL
  [02:53:58.939] plan(): nbrOfWorkers() = 1
  [02:53:58.941] plan(): Setting new future strategy stack:
  [02:53:58.941] List of future strategies:
  [02:53:58.941] 1. future:
  [02:53:58.941]    - args: function (...)
  [02:53:58.941]    - tweaked: FALSE
  [02:53:58.941]    - call: plan(foo)
  [02:53:58.942] plan(): nbrOfWorkers() = Inf
  [02:53:58.943] SequentialFuture started (and completed)
  [1] 42
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 28011
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/data/gannet/ripley/R/R-devel/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/Rtmpefujb5/future.parent=4175925.3fb83553b4e4df.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpxHETCY/working_dir/Rtmpefujb5/future.parent=4175925.3fb83553b4e4df.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/Future-class.R:gannet.stats.ox.ac.uk:ripley:4175925' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/Rtmpefujb5/future.parent=4175925.3fb83553b4e4df.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=28011 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  Error in get(name, envir = asNamespace(pkg), inherits = FALSE) : 
    object '.slaveRSOCK' not found
  Calls: ::: -> get
  Execution halted
  Killing worker process (PID 4176117) if still alive
  [02:56:00.203] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(4175925, signal = 0L)
  [1] TRUE
  Call: tools::pskill(4175925, signal = 0L)
  [1] TRUE
  [02:56:00.204] - success
  [02:56:00.204] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 4176117) was successfully killed: TRUE
  Error in makeRestartList(...) : 
    Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gannet.stats.ox.ac.uk'.
   * The error produced by socketConnection() was: 'reached elapsed time limit' (which suggests that the connection timeout of 120 seconds (argument 'connectTimeout') kicked in)
   * The localhost socket connection that failed to connect to the R worker used port 28011 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/Future-class.R:gannet.stats.ox.ac.uk:ripley:4175925' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/Rtmpefujb5/future.parent=4175925.3fb83553b4e4df.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=28011 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 4176117) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: clazz ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted
Running the tests in ‘tests/as.cluster.R’ failed.
Complete output:
  > source("incl/start.R")
  [02:56:04.463] plan(): Setting new future strategy stack:
  [02:56:04.465] List of future strategies:
  [02:56:04.465] 1. sequential:
  [02:56:04.465]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [02:56:04.465]    - tweaked: FALSE
  [02:56:04.465]    - call: future::plan("sequential")
  [02:56:04.468] plan(): nbrOfWorkers() = 1
  > stopCluster <- parallel::stopCluster
  > 
  > message("*** cluster operations ...")
  *** cluster operations ...
  > 
  > local({
  +   cl0 <- makeClusterPSOCK(1L)
  +   on.exit(stopCluster(cl0))
  +   cl <- cl0
  +   print(cl)
  + 
  +   message("*** cluster operations - as.cluster() ...")
  +   cl1 <- as.cluster(cl)
  +   print(cl1)
  +   stopifnot(inherits(cl1, "cluster"), identical(cl1, cl))
  + 
  +   node <- cl[[1]]
  +   print(node)
  +   cl2 <- as.cluster(cl)
  +   stopifnot(inherits(cl2, "cluster"), length(cl2) == 1L,
  +             identical(cl2[[1]], node))
  + 
  +   node <- cl[[1]]
  +   print(node)
  +   stopifnot(inherits(node, "SOCKnode"))
  +   nodes <- list(node, node)
  +   cl3 <- as.cluster(node)
  +   print(cl3)
  +   stopifnot(inherits(cl3, "cluster"), length(cl3) == 1L,
  +             identical(cl3[[1]], node))
  + 
  +   cl4 <- as.cluster(nodes)
  +   print(cl4)
  +   stopifnot(inherits(cl4, "cluster"), length(cl4) == 2L,
  +             identical(cl4[[1]], node), identical(cl4[[2]], node))
  +   
  +   message("*** cluster operations - as.cluster() ... DONE")
  + 
  +   message("*** cluster operations - c(...) ...")
  +   cl2 <- makeClusterPSOCK("localhost")
  +   on.exit(stopCluster(cl2), add = TRUE)
  +   print(cl2)
  +   
  +   cl <- c(cl1, cl2)
  +   print(cl)
  +   
  +   stopifnot(inherits(cl, "cluster"), length(cl) == 2L)
  +   stopifnot(identical(cl[1], cl1),
  +             identical(cl[2], cl2[1]))
  +   message("*** cluster operations - c(...) ... DONE")
  + })
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 36224
  [local output] Creating node 1 of 1 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/data/gannet/ripley/R/R-devel/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/Rtmp6iP9rJ/future.parent=4194118.3fff46652c0035.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpxHETCY/working_dir/Rtmp6iP9rJ/future.parent=4194118.3fff46652c0035.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/as.cluster.R:gannet.stats.ox.ac.uk:ripley:4194118' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/Rtmp6iP9rJ/future.parent=4194118.3fff46652c0035.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=36224 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  Error in get(name, envir = asNamespace(pkg), inherits = FALSE) : 
    object '.slaveRSOCK' not found
  Calls: ::: -> get
  Execution halted
  Killing worker process (PID 315) if still alive
  [02:58:05.737] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(4194118, signal = 0L)
  [1] TRUE
  Call: tools::pskill(4194118, signal = 0L)
  [1] TRUE
  [02:58:05.739] - success
  [02:58:05.739] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 315) was successfully killed: TRUE
  Error in makeRestartList(...) : 
    Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gannet.stats.ox.ac.uk'.
   * The error produced by socketConnection() was: 'reached elapsed time limit' (which suggests that the connection timeout of 120 seconds (argument 'connectTimeout') kicked in)
   * The localhost socket connection that failed to connect to the R worker used port 36224 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/as.cluster.R:gannet.stats.ox.ac.uk:ripley:4194118' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/Rtmp6iP9rJ/future.parent=4194118.3fff46652c0035.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=36224 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 315) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: local ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted
Running the tests in ‘tests/cluster.R’ failed.
Complete output:
  > source("incl/start.R")
  [02:58:13.454] plan(): Setting new future strategy stack:
  [02:58:13.457] List of future strategies:
  [02:58:13.457] 1. sequential:
  [02:58:13.457]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [02:58:13.457]    - tweaked: FALSE
  [02:58:13.457]    - call: future::plan("sequential")
  [02:58:13.460] plan(): nbrOfWorkers() = 1
  > library("listenv")
  > options(future.debug = FALSE)
  > message("*** cluster() ...")
  *** cluster() ...
  > 
  > message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
  Library paths: '/data/gannet/ripley/R/packages/tests-devel/future.Rcheck', '/data/gannet/ripley/R/test-4.1', '/data/gannet/ripley/R/R-devel/library'
  > message("Package path: ", sQuote(system.file(package = "future")))
  Package path: '/data/gannet/ripley/R/packages/tests-devel/future.Rcheck/future'
  > 
  > types <- "PSOCK"
  > 
  > ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
  > if (isWin32) types <- NULL
  > 
  > if (supportsMulticore() && !on_solaris) types <- c(types, "FORK")
  > 
  > ## WORKAROUND: covr::package_coverage() -> merge_coverage() -> ... produces
  > ## "Error in readRDS(x) : error reading from connection" for type = "FORK".
  > ## Is this related to mcparallel() comments in help("package_coverage")?
  > ## /HB 2017-05-20
  > if (covr_testing) types <- setdiff(types, "FORK")
  > 
  > pid <- Sys.getpid()
  > message("Main PID (original): ", pid)
  Main PID (original): 20675
  > cl <- NULL
  > for (type in types) {
  +   message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
  + 
  +   for (cores in 1:availCores) {
  +     message(sprintf("Testing with %d cores on type = %s ...",
  +                     cores, sQuote(type)))
  +     options(mc.cores = cores)
  +   
  +     ## Set up a cluster with <cores> nodes (explicitly)
  +     cl <- parallel::makeCluster(cores, type = type, timeout = 60)
  +     print(cl)
  +     
  +     plan(cluster, workers = cl)
  + 
  +     ## Assert that the worker's global environment is "empty"
  +     f <- future(ls(envir=globalenv(), all.names=TRUE))
  +     v <- value(f)
  +     v <- grep("^[.][.][.]future[.]", v, invert = TRUE, value = TRUE)
  +     if (length(v) > 0) {
  +       stop(sprintf("Stray variables in the global environment of %s: %s",
  +            class(f)[1], paste(sQuote(v), collapse = ", ")))
  +     }
  + 
  +     ## No global variables
  +     f <- try(cluster({
  +       42L
  +     }, workers = cl), silent = FALSE)
  +     print(f)
  +     stopifnot(inherits(f, "ClusterFuture"))
  +   
  +     print(resolved(f))
  +     y <- value(f)
  +     print(y)
  +     stopifnot(y == 42L)
  + 
  + 
  +     ## Set up a cluster with <cores> nodes (implicitly)
  +     plan(cluster, workers = cores)
  +   
  +     ## No global variables
  +     f <- try(cluster({
  +       42L
  +     }, workers = cl), silent = FALSE)
  +     print(f)
  +     stopifnot(inherits(f, "ClusterFuture"))
  +   
  +     print(resolved(f))
  +     y <- value(f)
  +     print(y)
  +     stopifnot(y == 42L)
  +   
  +   
  +     ## A global variable
  +     a <- 0
  +     f <- try(future({
  +       b <- 3
  +       c <- 2
  +       a * b * c
  +     }))
  +     print(f)
  +   
  +   
  +     ## A cluster future is evaluated in a separate
  +     ## R session process.  Changing the value of a global
  +     ## variable should not affect the result of the
  +     ## future.
  +     a <- 7  ## Make sure globals are frozen
  +     v <- value(f)
  +     print(v)
  +     stopifnot(v == 0)
  +   
  +   
  +     message("*** cluster() with globals and blocking")
  +     x <- listenv()
  +     for (ii in 1:3) {
  +       message(sprintf(" - Creating cluster future #%d ...", ii))
  +       x[[ii]] <- future({ ii })
  +     }
  +     message(sprintf(" - Resolving %d cluster futures", length(x)))
  +     v <- sapply(x, FUN = value)
  +     stopifnot(all(v == 1:3))
  +   
  +   
  +     message("*** cluster() and errors")
  +     f <- future({
  +       stop("Whoops!")
  +       1
  +     })
  +     print(f)
  +     v <- value(f, signal = FALSE)
  +     print(v)
  +     stopifnot(inherits(v, "simpleError"))
  +   
  +     res <- tryCatch(value(f), error = identity)
  +     print(res)
  +     stopifnot(inherits(res, "error"))
  +   
  +     ## Error is repeated
  +     res <- tryCatch(value(f), error = identity)
  +     print(res)
  +     stopifnot(inherits(res, "error"))
  +   
  +     ## Custom error class
  +     f <- future({
  +       stop(structure(list(message = "boom"),
  +                      class = c("MyError", "error", "condition")))
  +     })
  +     print(f)
  +     v <- value(f, signal = FALSE)
  +     print(v)
  +     stopifnot(inherits(v, "error"), inherits(v, "MyError"))
  +   
  +     ## Make sure error is signaled
  +     res <- tryCatch(value(f), error = identity)
  +     stopifnot(inherits(res, "error"), inherits(res, "MyError"))    
  +   
  +     message("*** cluster() - too large globals ...")
  +     ooptsT <- options(future.globals.maxSize = object.size(1:1014))
  +   
  +     limit <- getOption("future.globals.maxSize")
  +     cat(sprintf("Max total size of globals: %g bytes\n", limit))
  +   
  +     ## A large object
  +     a <- 1:1014
  +     yTruth <- sum(a)
  +     size <- object.size(a)
  +     cat(sprintf("a: %g bytes\n", size))
  +     f <- future({ sum(a) })
  +     print(f)
  +     rm(list = "a")
  +     v <- value(f)
  +     print(v)
  +     stopifnot(v == yTruth)
  +   
  +   
  +     ## A too large object
  +     a <- 1:1015
  +     yTruth <- sum(a)
  +     size <- object.size(a)
  +     cat(sprintf("a: %g bytes\n", size))
  +     res <- tryCatch(f <- future({ sum(a) }), error = identity)
  +     rm(list = "a")
  +     stopifnot(inherits(res, "error"))
  +   
  +     ## Undo options changed in this test
  +     options(ooptsT)
  +   
  +     message("*** cluster() - too large globals ... DONE")
  +   
  +     message("*** cluster() - installed libraries ...")
  +     f <- try(cluster({
  +       list(
  +         libPaths = .libPaths()
  +       )
  +     }, workers = cl), silent = FALSE)
  +     print(f)
  +     stopifnot(inherits(f, "ClusterFuture"))
  +     v <- value(f)
  +     message(paste(capture.output(str(v)), collapse = "\n"))
  +     message("*** cluster() - installed packages ... DONE")
  +   
  +   
  +     message("*** cluster() - assert covr workaround ...")
  +     f <- try(cluster({
  +       future:::hpaste(1:100)
  +     }, workers = cl), silent = FALSE)
  +     print(f)
  +     stopifnot(inherits(f, "ClusterFuture"))
  +     v <- value(f)
  +     message(v)
  +     stopifnot(v == hpaste(1:100))
  +     message("*** cluster() - assert covr workaround ... DONE")
  + 
  +     ## Assert that the worker's global environment is "empty"
  +     f <- future(ls(envir=globalenv(), all.names=TRUE))
  +     v <- value(f)
  +     v <- grep("^[.][.][.]future[.]", v, invert = TRUE, value = TRUE)
  +     if (length(v) > 0) {
  +       stop(sprintf("Stray variables in the global environment of %s: %s",
  +            class(f)[1], paste(sQuote(v), collapse = ", ")))
  +     }
  + 
  +     message(sprintf("Testing with %d cores on type = %s ... DONE",
  +                     cores, sQuote(type)))
  +   } ## for (cores ...)
  + 
  +   message("*** cluster() - exceptions ...")
  +   
  +   res <- tryCatch(cluster(42L, workers = NA), error = identity)
  +   print(res)
  +   stopifnot(inherits(res, "error"))
  +   
  +   message("*** cluster() - exceptions ... DONE")
  + 
  +   message("*** cluster() - assert registry behavior ...")
  +   
  +   ## Explicitly created clusters are *not* added to the registry
  +   cl <- parallel::makeCluster(1L, type = type, timeout = 60)
  +   plan(cluster, workers = cl)
  +   clR <- ClusterRegistry("get")
  +   stopifnot(is.null(clR))
  +   
  +   ## ... and therefore changing plans shouldn't change anything
  +   plan(sequential)
  +   clR <- ClusterRegistry("get")
  +   stopifnot(is.null(clR))
  +   
  +   message("*** cluster() - assert registry behavior ... DONE")
  + 
  +   ## Sanity checks
  +   pid2 <- Sys.getpid()
  +   message("Main PID (original): ", pid)
  +   message("Main PID: ", pid2)
  +   stopifnot(pid2 == pid)
  + 
  +   ## Cleanup
  +   print(cl)
  +   str(cl)
  +   parallel::stopCluster(cl)
  +   plan(sequential)
  + 
  +   cl1 <- parallel::makeCluster(1L, type = type, timeout = 60)
  +   plan(cluster, workers = cl1)
  +   f1 <- future(1)
  + 
  +   cl1 <- parallel::makeCluster(1L, type = type, timeout = 60)
  +   plan(cluster, workers = cl1)
  + 
  +   message(sprintf("Test set #1 with cluster type %s ... DONE", sQuote(type)))
  + } ## for (type ...)
  Test set #1 with cluster type 'PSOCK' ...
  Testing with 1 cores on type = 'PSOCK' ...
  socket cluster with 1 nodes on host 'localhost'
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      42L
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: c85ba479-f8bb-146e-7036-d68994aab90b
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [1] TRUE
  [1] 42
  Error in get(name, envir = asNamespace(pkg), inherits = FALSE) : 
    object '.slaveRSOCK' not found
  Calls: ::: -> get
  Execution halted
  Error in makeRestartList(...) : 
    Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gannet.stats.ox.ac.uk'.
   * The error produced by socketConnection() was: 'reached elapsed time limit' (which suggests that the connection timeout of 120 seconds (argument 'connectTimeout') kicked in)
   * The localhost socket connection that failed to connect to the R worker used port 22655 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/cluster.R:gannet.stats.ox.ac.uk:ripley:20675' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/Rtmp9fc7Bw/future.parent=20675.50c36fca7ab.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=22655 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 21014) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'verbose=TRUE' to see more details.
     - Suggestion #2: Set 'outfile=NULL' to see output from worker.
  Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted
Running the tests in ‘tests/demo.R’ failed.
Complete output:
  > source("incl/start.R")
  [03:00:17.842] plan(): Setting new future strategy stack:
  [03:00:17.844] List of future strategies:
  [03:00:17.844] 1. sequential:
  [03:00:17.844]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:17.844]    - tweaked: FALSE
  [03:00:17.844]    - call: future::plan("sequential")
  [03:00:17.847] plan(): nbrOfWorkers() = 1
  > 
  > message("*** Demos ...")
  *** Demos ...
  > 
  > message("*** Fibonacci demo of the 'future' package ...")
  *** Fibonacci demo of the 'future' package ...
  > demo("fibonacci", package = "future", ask = FALSE)
  
  
  	demo(fibonacci)
  	---- ~~~~~~~~~
  
  > library("future")
  
  > library("listenv")
  
  > ## IMPORTANT:
  > ## 1. The below usage of lazy futures will only work when they are
  > ##    all evaluated in the same process.
  > ## 2. We disable the capturing of standard output (stdout=NA) to avoid
  > ##    'sink stack is full' errors
  > ## 3. We disable the capturing of most conditions (condition="error") to
  > ##    avoid stacking up too many conditions
  > oplan <- plan(sequential)
  [03:00:17.910] plan(): Setting new future strategy stack:
  [03:00:17.911] List of future strategies:
  [03:00:17.911] 1. sequential:
  [03:00:17.911]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:17.911]    - tweaked: FALSE
  [03:00:17.911]    - call: plan(sequential)
  [03:00:17.956] plan(): nbrOfWorkers() = 1
  
  > ## Defines the first 100 Fibonacci numbers
  > ## (0, 1, 1, 2, 3, 5, 8, ...)
  > ## but calculate only the ones need when
  > ## a number is actually requested.
  > 
  > x <- listenv()
  
  > x[[1]] <- 0
  
  > x[[2]] <- 1
  
  > for (i in 3:100) {
  +   x[[i]] %<-% { x[[i - 2]] + x[[i - 1]] } %lazy% TRUE %stdout% NA %conditions% "error"
  + }
  [03:00:17.990] getGlobalsAndPackages() ...
  [03:00:17.991] Searching for globals...
  [03:00:18.004] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.005] Searching for globals ... DONE
  [03:00:18.006] Resolving globals: FALSE
  [03:00:18.009] The total size of the 2 globals is 224 bytes (224 bytes)
  [03:00:18.010] - globals: [2] 'x', 'i'
  [03:00:18.010] 
  [03:00:18.011] getGlobalsAndPackages() ... DONE
  [03:00:18.013] getGlobalsAndPackages() ...
  [03:00:18.014] Searching for globals...
  [03:00:18.019] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.019] Searching for globals ... DONE
  [03:00:18.020] Resolving globals: FALSE
  [03:00:18.023] The total size of the 2 globals is 8.10 KiB (8296 bytes)
  [03:00:18.024] - globals: [2] 'x', 'i'
  [03:00:18.024] 
  [03:00:18.025] getGlobalsAndPackages() ... DONE
  [03:00:18.027] getGlobalsAndPackages() ...
  [03:00:18.027] Searching for globals...
  [03:00:18.032] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.033] Searching for globals ... DONE
  [03:00:18.033] Resolving globals: FALSE
  [03:00:18.037] The total size of the 2 globals is 16.15 KiB (16536 bytes)
  [03:00:18.038] - globals: [2] 'x', 'i'
  [03:00:18.038] 
  [03:00:18.039] getGlobalsAndPackages() ... DONE
  [03:00:18.041] getGlobalsAndPackages() ...
  [03:00:18.041] Searching for globals...
  [03:00:18.046] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.047] Searching for globals ... DONE
  [03:00:18.047] Resolving globals: FALSE
  [03:00:18.053] The total size of the 2 globals is 24.20 KiB (24776 bytes)
  [03:00:18.053] - globals: [2] 'x', 'i'
  [03:00:18.054] 
  [03:00:18.054] getGlobalsAndPackages() ... DONE
  [03:00:18.056] getGlobalsAndPackages() ...
  [03:00:18.057] Searching for globals...
  [03:00:18.061] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.062] Searching for globals ... DONE
  [03:00:18.063] Resolving globals: FALSE
  [03:00:18.068] The total size of the 2 globals is 32.24 KiB (33016 bytes)
  [03:00:18.069] - globals: [2] 'x', 'i'
  [03:00:18.070] 
  [03:00:18.070] getGlobalsAndPackages() ... DONE
  [03:00:18.072] getGlobalsAndPackages() ...
  [03:00:18.073] Searching for globals...
  [03:00:18.077] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.078] Searching for globals ... DONE
  [03:00:18.079] Resolving globals: FALSE
  [03:00:18.085] The total size of the 2 globals is 40.29 KiB (41256 bytes)
  [03:00:18.086] - globals: [2] 'x', 'i'
  [03:00:18.086] 
  [03:00:18.087] getGlobalsAndPackages() ... DONE
  [03:00:18.089] getGlobalsAndPackages() ...
  [03:00:18.090] Searching for globals...
  [03:00:18.094] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.095] Searching for globals ... DONE
  [03:00:18.095] Resolving globals: FALSE
  [03:00:18.109] The total size of the 2 globals is 48.34 KiB (49496 bytes)
  [03:00:18.110] - globals: [2] 'x', 'i'
  [03:00:18.110] 
  [03:00:18.111] getGlobalsAndPackages() ... DONE
  [03:00:18.113] getGlobalsAndPackages() ...
  [03:00:18.113] Searching for globals...
  [03:00:18.118] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.119] Searching for globals ... DONE
  [03:00:18.119] Resolving globals: FALSE
  [03:00:18.128] The total size of the 2 globals is 56.38 KiB (57736 bytes)
  [03:00:18.129] - globals: [2] 'x', 'i'
  [03:00:18.129] 
  [03:00:18.130] getGlobalsAndPackages() ... DONE
  [03:00:18.132] getGlobalsAndPackages() ...
  [03:00:18.132] Searching for globals...
  [03:00:18.137] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.137] Searching for globals ... DONE
  [03:00:18.138] Resolving globals: FALSE
  [03:00:18.147] The total size of the 2 globals is 64.43 KiB (65976 bytes)
  [03:00:18.148] - globals: [2] 'x', 'i'
  [03:00:18.148] 
  [03:00:18.149] getGlobalsAndPackages() ... DONE
  [03:00:18.151] getGlobalsAndPackages() ...
  [03:00:18.151] Searching for globals...
  [03:00:18.156] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.156] Searching for globals ... DONE
  [03:00:18.157] Resolving globals: FALSE
  [03:00:18.167] The total size of the 2 globals is 72.48 KiB (74216 bytes)
  [03:00:18.168] - globals: [2] 'x', 'i'
  [03:00:18.168] 
  [03:00:18.169] getGlobalsAndPackages() ... DONE
  [03:00:18.171] getGlobalsAndPackages() ...
  [03:00:18.171] Searching for globals...
  [03:00:18.175] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.176] Searching for globals ... DONE
  [03:00:18.177] Resolving globals: FALSE
  [03:00:18.188] The total size of the 2 globals is 80.52 KiB (82456 bytes)
  [03:00:18.189] - globals: [2] 'x', 'i'
  [03:00:18.189] 
  [03:00:18.190] getGlobalsAndPackages() ... DONE
  [03:00:18.192] getGlobalsAndPackages() ...
  [03:00:18.192] Searching for globals...
  [03:00:18.200] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.200] Searching for globals ... DONE
  [03:00:18.201] Resolving globals: FALSE
  [03:00:18.214] The total size of the 2 globals is 88.57 KiB (90696 bytes)
  [03:00:18.214] - globals: [2] 'x', 'i'
  [03:00:18.215] 
  [03:00:18.215] getGlobalsAndPackages() ... DONE
  [03:00:18.217] getGlobalsAndPackages() ...
  [03:00:18.218] Searching for globals...
  [03:00:18.222] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.223] Searching for globals ... DONE
  [03:00:18.224] Resolving globals: FALSE
  [03:00:18.237] The total size of the 2 globals is 96.62 KiB (98936 bytes)
  [03:00:18.238] - globals: [2] 'x', 'i'
  [03:00:18.238] 
  [03:00:18.239] getGlobalsAndPackages() ... DONE
  [03:00:18.241] getGlobalsAndPackages() ...
  [03:00:18.241] Searching for globals...
  [03:00:18.245] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.246] Searching for globals ... DONE
  [03:00:18.247] Resolving globals: FALSE
  [03:00:18.261] The total size of the 2 globals is 104.66 KiB (107176 bytes)
  [03:00:18.261] - globals: [2] 'x', 'i'
  [03:00:18.262] 
  [03:00:18.262] getGlobalsAndPackages() ... DONE
  [03:00:18.264] getGlobalsAndPackages() ...
  [03:00:18.265] Searching for globals...
  [03:00:18.269] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.270] Searching for globals ... DONE
  [03:00:18.270] Resolving globals: FALSE
  [03:00:18.288] The total size of the 2 globals is 112.71 KiB (115416 bytes)
  [03:00:18.289] - globals: [2] 'x', 'i'
  [03:00:18.290] 
  [03:00:18.290] getGlobalsAndPackages() ... DONE
  [03:00:18.292] getGlobalsAndPackages() ...
  [03:00:18.293] Searching for globals...
  [03:00:18.297] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.298] Searching for globals ... DONE
  [03:00:18.298] Resolving globals: FALSE
  [03:00:18.317] The total size of the 2 globals is 120.76 KiB (123656 bytes)
  [03:00:18.318] - globals: [2] 'x', 'i'
  [03:00:18.319] 
  [03:00:18.319] getGlobalsAndPackages() ... DONE
  [03:00:18.321] getGlobalsAndPackages() ...
  [03:00:18.322] Searching for globals...
  [03:00:18.326] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.327] Searching for globals ... DONE
  [03:00:18.327] Resolving globals: FALSE
  [03:00:18.345] The total size of the 2 globals is 128.80 KiB (131896 bytes)
  [03:00:18.346] - globals: [2] 'x', 'i'
  [03:00:18.346] 
  [03:00:18.347] getGlobalsAndPackages() ... DONE
  [03:00:18.349] getGlobalsAndPackages() ...
  [03:00:18.349] Searching for globals...
  [03:00:18.354] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.355] Searching for globals ... DONE
  [03:00:18.355] Resolving globals: FALSE
  [03:00:18.374] The total size of the 2 globals is 136.85 KiB (140136 bytes)
  [03:00:18.375] - globals: [2] 'x', 'i'
  [03:00:18.379] 
  [03:00:18.379] getGlobalsAndPackages() ... DONE
  [03:00:18.381] getGlobalsAndPackages() ...
  [03:00:18.382] Searching for globals...
  [03:00:18.387] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.387] Searching for globals ... DONE
  [03:00:18.388] Resolving globals: FALSE
  [03:00:18.407] The total size of the 2 globals is 144.90 KiB (148376 bytes)
  [03:00:18.408] - globals: [2] 'x', 'i'
  [03:00:18.408] 
  [03:00:18.409] getGlobalsAndPackages() ... DONE
  [03:00:18.411] getGlobalsAndPackages() ...
  [03:00:18.411] Searching for globals...
  [03:00:18.415] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.416] Searching for globals ... DONE
  [03:00:18.417] Resolving globals: FALSE
  [03:00:18.436] The total size of the 2 globals is 152.95 KiB (156616 bytes)
  [03:00:18.436] - globals: [2] 'x', 'i'
  [03:00:18.437] 
  [03:00:18.438] getGlobalsAndPackages() ... DONE
  [03:00:18.439] getGlobalsAndPackages() ...
  [03:00:18.440] Searching for globals...
  [03:00:18.444] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.445] Searching for globals ... DONE
  [03:00:18.445] Resolving globals: FALSE
  [03:00:18.470] The total size of the 2 globals is 160.99 KiB (164856 bytes)
  [03:00:18.470] - globals: [2] 'x', 'i'
  [03:00:18.471] 
  [03:00:18.471] getGlobalsAndPackages() ... DONE
  [03:00:18.473] getGlobalsAndPackages() ...
  [03:00:18.474] Searching for globals...
  [03:00:18.478] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.479] Searching for globals ... DONE
  [03:00:18.480] Resolving globals: FALSE
  [03:00:18.501] The total size of the 2 globals is 169.04 KiB (173096 bytes)
  [03:00:18.502] - globals: [2] 'x', 'i'
  [03:00:18.502] 
  [03:00:18.503] getGlobalsAndPackages() ... DONE
  [03:00:18.504] getGlobalsAndPackages() ...
  [03:00:18.505] Searching for globals...
  [03:00:18.509] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.510] Searching for globals ... DONE
  [03:00:18.510] Resolving globals: FALSE
  [03:00:18.532] The total size of the 2 globals is 177.09 KiB (181336 bytes)
  [03:00:18.533] - globals: [2] 'x', 'i'
  [03:00:18.533] 
  [03:00:18.534] getGlobalsAndPackages() ... DONE
  [03:00:18.536] getGlobalsAndPackages() ...
  [03:00:18.536] Searching for globals...
  [03:00:18.543] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.544] Searching for globals ... DONE
  [03:00:18.545] Resolving globals: FALSE
  [03:00:18.571] The total size of the 2 globals is 185.13 KiB (189576 bytes)
  [03:00:18.571] - globals: [2] 'x', 'i'
  [03:00:18.572] 
  [03:00:18.572] getGlobalsAndPackages() ... DONE
  [03:00:18.574] getGlobalsAndPackages() ...
  [03:00:18.575] Searching for globals...
  [03:00:18.579] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.580] Searching for globals ... DONE
  [03:00:18.580] Resolving globals: FALSE
  [03:00:18.606] The total size of the 2 globals is 193.18 KiB (197816 bytes)
  [03:00:18.607] - globals: [2] 'x', 'i'
  [03:00:18.607] 
  [03:00:18.608] getGlobalsAndPackages() ... DONE
  [03:00:18.610] getGlobalsAndPackages() ...
  [03:00:18.610] Searching for globals...
  [03:00:18.615] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.615] Searching for globals ... DONE
  [03:00:18.616] Resolving globals: FALSE
  [03:00:18.646] The total size of the 2 globals is 201.23 KiB (206056 bytes)
  [03:00:18.647] - globals: [2] 'x', 'i'
  [03:00:18.648] 
  [03:00:18.648] getGlobalsAndPackages() ... DONE
  [03:00:18.650] getGlobalsAndPackages() ...
  [03:00:18.651] Searching for globals...
  [03:00:18.655] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.656] Searching for globals ... DONE
  [03:00:18.656] Resolving globals: FALSE
  [03:00:18.685] The total size of the 2 globals is 209.27 KiB (214296 bytes)
  [03:00:18.686] - globals: [2] 'x', 'i'
  [03:00:18.686] 
  [03:00:18.687] getGlobalsAndPackages() ... DONE
  [03:00:18.689] getGlobalsAndPackages() ...
  [03:00:18.689] Searching for globals...
  [03:00:18.694] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.695] Searching for globals ... DONE
  [03:00:18.695] Resolving globals: FALSE
  [03:00:18.728] The total size of the 2 globals is 217.32 KiB (222536 bytes)
  [03:00:18.729] - globals: [2] 'x', 'i'
  [03:00:18.729] 
  [03:00:18.730] getGlobalsAndPackages() ... DONE
  [03:00:18.732] getGlobalsAndPackages() ...
  [03:00:18.732] Searching for globals...
  [03:00:18.737] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.738] Searching for globals ... DONE
  [03:00:18.738] Resolving globals: FALSE
  [03:00:18.795] The total size of the 2 globals is 225.37 KiB (230776 bytes)
  [03:00:18.796] - globals: [2] 'x', 'i'
  [03:00:18.797] 
  [03:00:18.797] getGlobalsAndPackages() ... DONE
  [03:00:18.799] getGlobalsAndPackages() ...
  [03:00:18.800] Searching for globals...
  [03:00:18.817] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.818] Searching for globals ... DONE
  [03:00:18.819] Resolving globals: FALSE
  [03:00:18.878] The total size of the 2 globals is 233.41 KiB (239016 bytes)
  [03:00:18.879] - globals: [2] 'x', 'i'
  [03:00:18.880] 
  [03:00:18.880] getGlobalsAndPackages() ... DONE
  [03:00:18.882] getGlobalsAndPackages() ...
  [03:00:18.883] Searching for globals...
  [03:00:18.887] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.888] Searching for globals ... DONE
  [03:00:18.889] Resolving globals: FALSE
  [03:00:18.921] The total size of the 2 globals is 241.46 KiB (247256 bytes)
  [03:00:18.921] - globals: [2] 'x', 'i'
  [03:00:18.922] 
  [03:00:18.923] getGlobalsAndPackages() ... DONE
  [03:00:18.925] getGlobalsAndPackages() ...
  [03:00:18.925] Searching for globals...
  [03:00:18.930] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.930] Searching for globals ... DONE
  [03:00:18.931] Resolving globals: FALSE
  [03:00:18.968] The total size of the 2 globals is 249.51 KiB (255496 bytes)
  [03:00:18.969] - globals: [2] 'x', 'i'
  [03:00:18.969] 
  [03:00:18.970] getGlobalsAndPackages() ... DONE
  [03:00:18.972] getGlobalsAndPackages() ...
  [03:00:18.973] Searching for globals...
  [03:00:18.977] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:18.978] Searching for globals ... DONE
  [03:00:18.978] Resolving globals: FALSE
  [03:00:19.016] The total size of the 2 globals is 257.55 KiB (263736 bytes)
  [03:00:19.017] - globals: [2] 'x', 'i'
  [03:00:19.017] 
  [03:00:19.018] getGlobalsAndPackages() ... DONE
  [03:00:19.020] getGlobalsAndPackages() ...
  [03:00:19.020] Searching for globals...
  [03:00:19.025] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.025] Searching for globals ... DONE
  [03:00:19.026] Resolving globals: FALSE
  [03:00:19.061] The total size of the 2 globals is 265.60 KiB (271976 bytes)
  [03:00:19.061] - globals: [2] 'x', 'i'
  [03:00:19.062] 
  [03:00:19.062] getGlobalsAndPackages() ... DONE
  [03:00:19.064] getGlobalsAndPackages() ...
  [03:00:19.065] Searching for globals...
  [03:00:19.069] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.070] Searching for globals ... DONE
  [03:00:19.071] Resolving globals: FALSE
  [03:00:19.109] The total size of the 2 globals is 273.65 KiB (280216 bytes)
  [03:00:19.110] - globals: [2] 'x', 'i'
  [03:00:19.111] 
  [03:00:19.111] getGlobalsAndPackages() ... DONE
  [03:00:19.113] getGlobalsAndPackages() ...
  [03:00:19.114] Searching for globals...
  [03:00:19.118] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.119] Searching for globals ... DONE
  [03:00:19.119] Resolving globals: FALSE
  [03:00:19.156] The total size of the 2 globals is 281.70 KiB (288456 bytes)
  [03:00:19.157] - globals: [2] 'x', 'i'
  [03:00:19.158] 
  [03:00:19.158] getGlobalsAndPackages() ... DONE
  [03:00:19.160] getGlobalsAndPackages() ...
  [03:00:19.161] Searching for globals...
  [03:00:19.169] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.170] Searching for globals ... DONE
  [03:00:19.170] Resolving globals: FALSE
  [03:00:19.208] The total size of the 2 globals is 289.74 KiB (296696 bytes)
  [03:00:19.209] - globals: [2] 'x', 'i'
  [03:00:19.209] 
  [03:00:19.210] getGlobalsAndPackages() ... DONE
  [03:00:19.212] getGlobalsAndPackages() ...
  [03:00:19.212] Searching for globals...
  [03:00:19.217] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.217] Searching for globals ... DONE
  [03:00:19.218] Resolving globals: FALSE
  [03:00:19.262] The total size of the 2 globals is 297.79 KiB (304936 bytes)
  [03:00:19.262] - globals: [2] 'x', 'i'
  [03:00:19.263] 
  [03:00:19.263] getGlobalsAndPackages() ... DONE
  [03:00:19.266] getGlobalsAndPackages() ...
  [03:00:19.266] Searching for globals...
  [03:00:19.270] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.271] Searching for globals ... DONE
  [03:00:19.272] Resolving globals: FALSE
  [03:00:19.320] The total size of the 2 globals is 305.84 KiB (313176 bytes)
  [03:00:19.321] - globals: [2] 'x', 'i'
  [03:00:19.322] 
  [03:00:19.322] getGlobalsAndPackages() ... DONE
  [03:00:19.324] getGlobalsAndPackages() ...
  [03:00:19.325] Searching for globals...
  [03:00:19.332] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.333] Searching for globals ... DONE
  [03:00:19.333] Resolving globals: FALSE
  [03:00:19.402] The total size of the 2 globals is 313.88 KiB (321416 bytes)
  [03:00:19.402] - globals: [2] 'x', 'i'
  [03:00:19.403] 
  [03:00:19.404] getGlobalsAndPackages() ... DONE
  [03:00:19.414] getGlobalsAndPackages() ...
  [03:00:19.414] Searching for globals...
  [03:00:19.419] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.420] Searching for globals ... DONE
  [03:00:19.420] Resolving globals: FALSE
  [03:00:19.479] The total size of the 2 globals is 321.93 KiB (329656 bytes)
  [03:00:19.479] - globals: [2] 'x', 'i'
  [03:00:19.480] 
  [03:00:19.481] getGlobalsAndPackages() ... DONE
  [03:00:19.482] getGlobalsAndPackages() ...
  [03:00:19.483] Searching for globals...
  [03:00:19.487] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.488] Searching for globals ... DONE
  [03:00:19.488] Resolving globals: FALSE
  [03:00:19.537] The total size of the 2 globals is 329.98 KiB (337896 bytes)
  [03:00:19.538] - globals: [2] 'x', 'i'
  [03:00:19.539] 
  [03:00:19.539] getGlobalsAndPackages() ... DONE
  [03:00:19.541] getGlobalsAndPackages() ...
  [03:00:19.542] Searching for globals...
  [03:00:19.546] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.547] Searching for globals ... DONE
  [03:00:19.547] Resolving globals: FALSE
  [03:00:19.590] The total size of the 2 globals is 338.02 KiB (346136 bytes)
  [03:00:19.591] - globals: [2] 'x', 'i'
  [03:00:19.592] 
  [03:00:19.592] getGlobalsAndPackages() ... DONE
  [03:00:19.594] getGlobalsAndPackages() ...
  [03:00:19.595] Searching for globals...
  [03:00:19.602] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.603] Searching for globals ... DONE
  [03:00:19.603] Resolving globals: FALSE
  [03:00:19.648] The total size of the 2 globals is 346.07 KiB (354376 bytes)
  [03:00:19.648] - globals: [2] 'x', 'i'
  [03:00:19.649] 
  [03:00:19.649] getGlobalsAndPackages() ... DONE
  [03:00:19.651] getGlobalsAndPackages() ...
  [03:00:19.652] Searching for globals...
  [03:00:19.656] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.657] Searching for globals ... DONE
  [03:00:19.657] Resolving globals: FALSE
  [03:00:19.748] The total size of the 2 globals is 354.12 KiB (362616 bytes)
  [03:00:19.749] - globals: [2] 'x', 'i'
  [03:00:19.750] 
  [03:00:19.750] getGlobalsAndPackages() ... DONE
  [03:00:19.752] getGlobalsAndPackages() ...
  [03:00:19.753] Searching for globals...
  [03:00:19.757] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.758] Searching for globals ... DONE
  [03:00:19.758] Resolving globals: FALSE
  [03:00:19.810] The total size of the 2 globals is 362.16 KiB (370856 bytes)
  [03:00:19.810] - globals: [2] 'x', 'i'
  [03:00:19.811] 
  [03:00:19.811] getGlobalsAndPackages() ... DONE
  [03:00:19.814] getGlobalsAndPackages() ...
  [03:00:19.814] Searching for globals...
  [03:00:19.819] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.819] Searching for globals ... DONE
  [03:00:19.820] Resolving globals: FALSE
  [03:00:19.871] The total size of the 2 globals is 370.21 KiB (379096 bytes)
  [03:00:19.872] - globals: [2] 'x', 'i'
  [03:00:19.872] 
  [03:00:19.873] getGlobalsAndPackages() ... DONE
  [03:00:19.875] getGlobalsAndPackages() ...
  [03:00:19.876] Searching for globals...
  [03:00:19.880] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.880] Searching for globals ... DONE
  [03:00:19.881] Resolving globals: FALSE
  [03:00:19.931] The total size of the 2 globals is 378.26 KiB (387336 bytes)
  [03:00:19.931] - globals: [2] 'x', 'i'
  [03:00:19.932] 
  [03:00:19.932] getGlobalsAndPackages() ... DONE
  [03:00:19.939] getGlobalsAndPackages() ...
  [03:00:19.939] Searching for globals...
  [03:00:19.944] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:19.945] Searching for globals ... DONE
  [03:00:19.945] Resolving globals: FALSE
  [03:00:19.999] The total size of the 2 globals is 386.30 KiB (395576 bytes)
  [03:00:20.000] - globals: [2] 'x', 'i'
  [03:00:20.000] 
  [03:00:20.001] getGlobalsAndPackages() ... DONE
  [03:00:20.003] getGlobalsAndPackages() ...
  [03:00:20.003] Searching for globals...
  [03:00:20.010] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.010] Searching for globals ... DONE
  [03:00:20.011] Resolving globals: FALSE
  [03:00:20.064] The total size of the 2 globals is 394.35 KiB (403816 bytes)
  [03:00:20.065] - globals: [2] 'x', 'i'
  [03:00:20.066] 
  [03:00:20.066] getGlobalsAndPackages() ... DONE
  [03:00:20.068] getGlobalsAndPackages() ...
  [03:00:20.069] Searching for globals...
  [03:00:20.073] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.074] Searching for globals ... DONE
  [03:00:20.074] Resolving globals: FALSE
  [03:00:20.128] The total size of the 2 globals is 402.40 KiB (412056 bytes)
  [03:00:20.128] - globals: [2] 'x', 'i'
  [03:00:20.129] 
  [03:00:20.129] getGlobalsAndPackages() ... DONE
  [03:00:20.131] getGlobalsAndPackages() ...
  [03:00:20.132] Searching for globals...
  [03:00:20.136] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.136] Searching for globals ... DONE
  [03:00:20.137] Resolving globals: FALSE
  [03:00:20.195] The total size of the 2 globals is 410.45 KiB (420296 bytes)
  [03:00:20.196] - globals: [2] 'x', 'i'
  [03:00:20.196] 
  [03:00:20.197] getGlobalsAndPackages() ... DONE
  [03:00:20.199] getGlobalsAndPackages() ...
  [03:00:20.199] Searching for globals...
  [03:00:20.205] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.206] Searching for globals ... DONE
  [03:00:20.206] Resolving globals: FALSE
  [03:00:20.267] The total size of the 2 globals is 418.49 KiB (428536 bytes)
  [03:00:20.267] - globals: [2] 'x', 'i'
  [03:00:20.268] 
  [03:00:20.268] getGlobalsAndPackages() ... DONE
  [03:00:20.270] getGlobalsAndPackages() ...
  [03:00:20.271] Searching for globals...
  [03:00:20.275] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.276] Searching for globals ... DONE
  [03:00:20.277] Resolving globals: FALSE
  [03:00:20.334] The total size of the 2 globals is 426.54 KiB (436776 bytes)
  [03:00:20.335] - globals: [2] 'x', 'i'
  [03:00:20.335] 
  [03:00:20.336] getGlobalsAndPackages() ... DONE
  [03:00:20.337] getGlobalsAndPackages() ...
  [03:00:20.338] Searching for globals...
  [03:00:20.342] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.343] Searching for globals ... DONE
  [03:00:20.343] Resolving globals: FALSE
  [03:00:20.403] The total size of the 2 globals is 434.59 KiB (445016 bytes)
  [03:00:20.404] - globals: [2] 'x', 'i'
  [03:00:20.404] 
  [03:00:20.405] getGlobalsAndPackages() ... DONE
  [03:00:20.407] getGlobalsAndPackages() ...
  [03:00:20.408] Searching for globals...
  [03:00:20.412] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.413] Searching for globals ... DONE
  [03:00:20.413] Resolving globals: FALSE
  [03:00:20.480] The total size of the 2 globals is 442.63 KiB (453256 bytes)
  [03:00:20.480] - globals: [2] 'x', 'i'
  [03:00:20.481] 
  [03:00:20.481] getGlobalsAndPackages() ... DONE
  [03:00:20.483] getGlobalsAndPackages() ...
  [03:00:20.484] Searching for globals...
  [03:00:20.489] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.489] Searching for globals ... DONE
  [03:00:20.490] Resolving globals: FALSE
  [03:00:20.560] The total size of the 2 globals is 450.68 KiB (461496 bytes)
  [03:00:20.561] - globals: [2] 'x', 'i'
  [03:00:20.561] 
  [03:00:20.562] getGlobalsAndPackages() ... DONE
  [03:00:20.564] getGlobalsAndPackages() ...
  [03:00:20.565] Searching for globals...
  [03:00:20.570] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.570] Searching for globals ... DONE
  [03:00:20.571] Resolving globals: FALSE
  [03:00:20.637] The total size of the 2 globals is 458.73 KiB (469736 bytes)
  [03:00:20.638] - globals: [2] 'x', 'i'
  [03:00:20.639] 
  [03:00:20.639] getGlobalsAndPackages() ... DONE
  [03:00:20.641] getGlobalsAndPackages() ...
  [03:00:20.642] Searching for globals...
  [03:00:20.646] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.647] Searching for globals ... DONE
  [03:00:20.648] Resolving globals: FALSE
  [03:00:20.718] The total size of the 2 globals is 466.77 KiB (477976 bytes)
  [03:00:20.719] - globals: [2] 'x', 'i'
  [03:00:20.720] 
  [03:00:20.720] getGlobalsAndPackages() ... DONE
  [03:00:20.722] getGlobalsAndPackages() ...
  [03:00:20.723] Searching for globals...
  [03:00:20.727] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.728] Searching for globals ... DONE
  [03:00:20.729] Resolving globals: FALSE
  [03:00:20.798] The total size of the 2 globals is 474.82 KiB (486216 bytes)
  [03:00:20.799] - globals: [2] 'x', 'i'
  [03:00:20.800] 
  [03:00:20.800] getGlobalsAndPackages() ... DONE
  [03:00:20.802] getGlobalsAndPackages() ...
  [03:00:20.803] Searching for globals...
  [03:00:20.807] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.808] Searching for globals ... DONE
  [03:00:20.809] Resolving globals: FALSE
  [03:00:20.881] The total size of the 2 globals is 482.87 KiB (494456 bytes)
  [03:00:20.882] - globals: [2] 'x', 'i'
  [03:00:20.882] 
  [03:00:20.883] getGlobalsAndPackages() ... DONE
  [03:00:20.885] getGlobalsAndPackages() ...
  [03:00:20.885] Searching for globals...
  [03:00:20.890] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.890] Searching for globals ... DONE
  [03:00:20.891] Resolving globals: FALSE
  [03:00:20.961] The total size of the 2 globals is 490.91 KiB (502696 bytes)
  [03:00:20.962] - globals: [2] 'x', 'i'
  [03:00:20.963] 
  [03:00:20.963] getGlobalsAndPackages() ... DONE
  [03:00:20.965] getGlobalsAndPackages() ...
  [03:00:20.966] Searching for globals...
  [03:00:20.970] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:20.971] Searching for globals ... DONE
  [03:00:20.972] Resolving globals: FALSE
  [03:00:21.047] The total size of the 2 globals is 498.96 KiB (510936 bytes)
  [03:00:21.048] - globals: [2] 'x', 'i'
  [03:00:21.049] 
  [03:00:21.049] getGlobalsAndPackages() ... DONE
  [03:00:21.051] getGlobalsAndPackages() ...
  [03:00:21.052] Searching for globals...
  [03:00:21.057] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:21.058] Searching for globals ... DONE
  [03:00:21.058] Resolving globals: FALSE
  [03:00:21.153] The total size of the 2 globals is 507.01 KiB (519176 bytes)
  [03:00:21.154] - globals: [2] 'x', 'i'
  [03:00:21.154] 
  [03:00:21.155] getGlobalsAndPackages() ... DONE
  [03:00:21.157] getGlobalsAndPackages() ...
  [03:00:21.157] Searching for globals...
  [03:00:21.161] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:21.162] Searching for globals ... DONE
  [03:00:21.166] Resolving globals: FALSE
  [03:00:21.251] The total size of the 2 globals is 515.05 KiB (527416 bytes)
  [03:00:21.252] - globals: [2] 'x', 'i'
  [03:00:21.252] 
  [03:00:21.253] getGlobalsAndPackages() ... DONE
  [03:00:21.254] getGlobalsAndPackages() ...
  [03:00:21.255] Searching for globals...
  [03:00:21.259] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:21.260] Searching for globals ... DONE
  [03:00:21.261] Resolving globals: FALSE
  [03:00:21.335] The total size of the 2 globals is 523.10 KiB (535656 bytes)
  [03:00:21.336] - globals: [2] 'x', 'i'
  [03:00:21.336] 
  [03:00:21.337] getGlobalsAndPackages() ... DONE
  [03:00:21.339] getGlobalsAndPackages() ...
  [03:00:21.339] Searching for globals...
  [03:00:21.343] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:21.344] Searching for globals ... DONE
  [03:00:21.344] Resolving globals: FALSE
  [03:00:21.419] The total size of the 2 globals is 531.15 KiB (543896 bytes)
  [03:00:21.420] - globals: [2] 'x', 'i'
  [03:00:21.420] 
  [03:00:21.421] getGlobalsAndPackages() ... DONE
  [03:00:21.423] getGlobalsAndPackages() ...
  [03:00:21.423] Searching for globals...
  [03:00:21.428] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:21.428] Searching for globals ... DONE
  [03:00:21.429] Resolving globals: FALSE
  [03:00:21.510] The total size of the 2 globals is 539.20 KiB (552136 bytes)
  [03:00:21.511] - globals: [2] 'x', 'i'
  [03:00:21.511] 
  [03:00:21.512] getGlobalsAndPackages() ... DONE
  [03:00:21.514] getGlobalsAndPackages() ...
  [03:00:21.515] Searching for globals...
  [03:00:21.519] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:21.519] Searching for globals ... DONE
  [03:00:21.520] Resolving globals: FALSE
  [03:00:21.596] The total size of the 2 globals is 547.24 KiB (560376 bytes)
  [03:00:21.597] - globals: [2] 'x', 'i'
  [03:00:21.598] 
  [03:00:21.598] getGlobalsAndPackages() ... DONE
  [03:00:21.600] getGlobalsAndPackages() ...
  [03:00:21.601] Searching for globals...
  [03:00:21.605] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:21.605] Searching for globals ... DONE
  [03:00:21.606] Resolving globals: FALSE
  [03:00:21.681] The total size of the 2 globals is 555.29 KiB (568616 bytes)
  [03:00:21.681] - globals: [2] 'x', 'i'
  [03:00:21.684] 
  [03:00:21.684] getGlobalsAndPackages() ... DONE
  [03:00:21.686] getGlobalsAndPackages() ...
  [03:00:21.687] Searching for globals...
  [03:00:21.691] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:21.692] Searching for globals ... DONE
  [03:00:21.692] Resolving globals: FALSE
  [03:00:21.774] The total size of the 2 globals is 563.34 KiB (576856 bytes)
  [03:00:21.775] - globals: [2] 'x', 'i'
  [03:00:21.775] 
  [03:00:21.776] getGlobalsAndPackages() ... DONE
  [03:00:21.778] getGlobalsAndPackages() ...
  [03:00:21.778] Searching for globals...
  [03:00:21.782] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:21.783] Searching for globals ... DONE
  [03:00:21.784] Resolving globals: FALSE
  [03:00:21.867] The total size of the 2 globals is 571.38 KiB (585096 bytes)
  [03:00:21.868] - globals: [2] 'x', 'i'
  [03:00:21.869] 
  [03:00:21.869] getGlobalsAndPackages() ... DONE
  [03:00:21.871] getGlobalsAndPackages() ...
  [03:00:21.871] Searching for globals...
  [03:00:21.875] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:21.876] Searching for globals ... DONE
  [03:00:21.877] Resolving globals: FALSE
  [03:00:21.957] The total size of the 2 globals is 579.43 KiB (593336 bytes)
  [03:00:21.958] - globals: [2] 'x', 'i'
  [03:00:21.958] 
  [03:00:21.959] getGlobalsAndPackages() ... DONE
  [03:00:21.961] getGlobalsAndPackages() ...
  [03:00:21.961] Searching for globals...
  [03:00:21.966] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:21.966] Searching for globals ... DONE
  [03:00:21.967] Resolving globals: FALSE
  [03:00:22.044] The total size of the 2 globals is 587.48 KiB (601576 bytes)
  [03:00:22.045] - globals: [2] 'x', 'i'
  [03:00:22.046] 
  [03:00:22.046] getGlobalsAndPackages() ... DONE
  [03:00:22.048] getGlobalsAndPackages() ...
  [03:00:22.048] Searching for globals...
  [03:00:22.052] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:22.053] Searching for globals ... DONE
  [03:00:22.054] Resolving globals: FALSE
  [03:00:22.146] The total size of the 2 globals is 595.52 KiB (609816 bytes)
  [03:00:22.147] - globals: [2] 'x', 'i'
  [03:00:22.148] 
  [03:00:22.148] getGlobalsAndPackages() ... DONE
  [03:00:22.151] getGlobalsAndPackages() ...
  [03:00:22.151] Searching for globals...
  [03:00:22.156] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:22.156] Searching for globals ... DONE
  [03:00:22.157] Resolving globals: FALSE
  [03:00:22.259] The total size of the 2 globals is 603.57 KiB (618056 bytes)
  [03:00:22.260] - globals: [2] 'x', 'i'
  [03:00:22.260] 
  [03:00:22.261] getGlobalsAndPackages() ... DONE
  [03:00:22.263] getGlobalsAndPackages() ...
  [03:00:22.264] Searching for globals...
  [03:00:22.268] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:22.269] Searching for globals ... DONE
  [03:00:22.270] Resolving globals: FALSE
  [03:00:22.392] The total size of the 2 globals is 611.62 KiB (626296 bytes)
  [03:00:22.393] - globals: [2] 'x', 'i'
  [03:00:22.394] 
  [03:00:22.394] getGlobalsAndPackages() ... DONE
  [03:00:22.396] getGlobalsAndPackages() ...
  [03:00:22.397] Searching for globals...
  [03:00:22.402] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:22.402] Searching for globals ... DONE
  [03:00:22.403] Resolving globals: FALSE
  [03:00:22.477] The total size of the 2 globals is 619.66 KiB (634536 bytes)
  [03:00:22.477] - globals: [2] 'x', 'i'
  [03:00:22.478] 
  [03:00:22.478] getGlobalsAndPackages() ... DONE
  [03:00:22.480] getGlobalsAndPackages() ...
  [03:00:22.481] Searching for globals...
  [03:00:22.486] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:22.487] Searching for globals ... DONE
  [03:00:22.487] Resolving globals: FALSE
  [03:00:22.590] The total size of the 2 globals is 627.71 KiB (642776 bytes)
  [03:00:22.591] - globals: [2] 'x', 'i'
  [03:00:22.592] 
  [03:00:22.592] getGlobalsAndPackages() ... DONE
  [03:00:22.594] getGlobalsAndPackages() ...
  [03:00:22.595] Searching for globals...
  [03:00:22.600] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:22.601] Searching for globals ... DONE
  [03:00:22.601] Resolving globals: FALSE
  [03:00:22.699] The total size of the 2 globals is 635.76 KiB (651016 bytes)
  [03:00:22.700] - globals: [2] 'x', 'i'
  [03:00:22.701] 
  [03:00:22.701] getGlobalsAndPackages() ... DONE
  [03:00:22.703] getGlobalsAndPackages() ...
  [03:00:22.704] Searching for globals...
  [03:00:22.709] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:22.710] Searching for globals ... DONE
  [03:00:22.710] Resolving globals: FALSE
  [03:00:22.827] The total size of the 2 globals is 643.80 KiB (659256 bytes)
  [03:00:22.828] - globals: [2] 'x', 'i'
  [03:00:22.828] 
  [03:00:22.829] getGlobalsAndPackages() ... DONE
  [03:00:22.831] getGlobalsAndPackages() ...
  [03:00:22.831] Searching for globals...
  [03:00:22.836] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:22.837] Searching for globals ... DONE
  [03:00:22.838] Resolving globals: FALSE
  [03:00:22.941] The total size of the 2 globals is 651.85 KiB (667496 bytes)
  [03:00:22.941] - globals: [2] 'x', 'i'
  [03:00:22.942] 
  [03:00:22.942] getGlobalsAndPackages() ... DONE
  [03:00:22.945] getGlobalsAndPackages() ...
  [03:00:22.945] Searching for globals...
  [03:00:22.950] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:22.951] Searching for globals ... DONE
  [03:00:22.951] Resolving globals: FALSE
  [03:00:23.057] The total size of the 2 globals is 659.90 KiB (675736 bytes)
  [03:00:23.058] - globals: [2] 'x', 'i'
  [03:00:23.059] 
  [03:00:23.059] getGlobalsAndPackages() ... DONE
  [03:00:23.061] getGlobalsAndPackages() ...
  [03:00:23.062] Searching for globals...
  [03:00:23.067] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:23.067] Searching for globals ... DONE
  [03:00:23.068] Resolving globals: FALSE
  [03:00:23.181] The total size of the 2 globals is 667.95 KiB (683976 bytes)
  [03:00:23.182] - globals: [2] 'x', 'i'
  [03:00:23.183] 
  [03:00:23.183] getGlobalsAndPackages() ... DONE
  [03:00:23.185] getGlobalsAndPackages() ...
  [03:00:23.186] Searching for globals...
  [03:00:23.193] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:23.194] Searching for globals ... DONE
  [03:00:23.195] Resolving globals: FALSE
  [03:00:23.299] The total size of the 2 globals is 675.99 KiB (692216 bytes)
  [03:00:23.300] - globals: [2] 'x', 'i'
  [03:00:23.300] 
  [03:00:23.301] getGlobalsAndPackages() ... DONE
  [03:00:23.303] getGlobalsAndPackages() ...
  [03:00:23.303] Searching for globals...
  [03:00:23.308] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:23.309] Searching for globals ... DONE
  [03:00:23.309] Resolving globals: FALSE
  [03:00:23.441] The total size of the 2 globals is 684.04 KiB (700456 bytes)
  [03:00:23.442] - globals: [2] 'x', 'i'
  [03:00:23.443] 
  [03:00:23.443] getGlobalsAndPackages() ... DONE
  [03:00:23.445] getGlobalsAndPackages() ...
  [03:00:23.446] Searching for globals...
  [03:00:23.450] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:23.451] Searching for globals ... DONE
  [03:00:23.452] Resolving globals: FALSE
  [03:00:23.563] The total size of the 2 globals is 692.09 KiB (708696 bytes)
  [03:00:23.564] - globals: [2] 'x', 'i'
  [03:00:23.564] 
  [03:00:23.565] getGlobalsAndPackages() ... DONE
  [03:00:23.567] getGlobalsAndPackages() ...
  [03:00:23.567] Searching for globals...
  [03:00:23.584] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:23.585] Searching for globals ... DONE
  [03:00:23.585] Resolving globals: FALSE
  [03:00:23.700] The total size of the 2 globals is 700.13 KiB (716936 bytes)
  [03:00:23.701] - globals: [2] 'x', 'i'
  [03:00:23.702] 
  [03:00:23.702] getGlobalsAndPackages() ... DONE
  [03:00:23.704] getGlobalsAndPackages() ...
  [03:00:23.705] Searching for globals...
  [03:00:23.709] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:23.710] Searching for globals ... DONE
  [03:00:23.710] Resolving globals: FALSE
  [03:00:23.820] The total size of the 2 globals is 708.18 KiB (725176 bytes)
  [03:00:23.821] - globals: [2] 'x', 'i'
  [03:00:23.821] 
  [03:00:23.822] getGlobalsAndPackages() ... DONE
  [03:00:23.824] getGlobalsAndPackages() ...
  [03:00:23.824] Searching for globals...
  [03:00:23.829] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:23.830] Searching for globals ... DONE
  [03:00:23.830] Resolving globals: FALSE
  [03:00:23.935] The total size of the 2 globals is 716.23 KiB (733416 bytes)
  [03:00:23.935] - globals: [2] 'x', 'i'
  [03:00:23.936] 
  [03:00:23.936] getGlobalsAndPackages() ... DONE
  [03:00:23.938] getGlobalsAndPackages() ...
  [03:00:23.939] Searching for globals...
  [03:00:23.943] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:23.944] Searching for globals ... DONE
  [03:00:23.944] Resolving globals: FALSE
  [03:00:24.047] The total size of the 2 globals is 724.27 KiB (741656 bytes)
  [03:00:24.048] - globals: [2] 'x', 'i'
  [03:00:24.048] 
  [03:00:24.049] getGlobalsAndPackages() ... DONE
  [03:00:24.051] getGlobalsAndPackages() ...
  [03:00:24.052] Searching for globals...
  [03:00:24.056] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:24.057] Searching for globals ... DONE
  [03:00:24.057] Resolving globals: FALSE
  [03:00:24.164] The total size of the 2 globals is 732.32 KiB (749896 bytes)
  [03:00:24.165] - globals: [2] 'x', 'i'
  [03:00:24.165] 
  [03:00:24.166] getGlobalsAndPackages() ... DONE
  [03:00:24.168] getGlobalsAndPackages() ...
  [03:00:24.168] Searching for globals...
  [03:00:24.173] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:24.173] Searching for globals ... DONE
  [03:00:24.174] Resolving globals: FALSE
  [03:00:24.278] The total size of the 2 globals is 740.37 KiB (758136 bytes)
  [03:00:24.279] - globals: [2] 'x', 'i'
  [03:00:24.280] 
  [03:00:24.280] getGlobalsAndPackages() ... DONE
  [03:00:24.282] getGlobalsAndPackages() ...
  [03:00:24.283] Searching for globals...
  [03:00:24.287] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:24.287] Searching for globals ... DONE
  [03:00:24.288] Resolving globals: FALSE
  [03:00:24.396] The total size of the 2 globals is 748.41 KiB (766376 bytes)
  [03:00:24.397] - globals: [2] 'x', 'i'
  [03:00:24.397] 
  [03:00:24.398] getGlobalsAndPackages() ... DONE
  [03:00:24.400] getGlobalsAndPackages() ...
  [03:00:24.400] Searching for globals...
  [03:00:24.405] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:24.405] Searching for globals ... DONE
  [03:00:24.406] Resolving globals: FALSE
  [03:00:24.529] The total size of the 2 globals is 756.46 KiB (774616 bytes)
  [03:00:24.530] - globals: [2] 'x', 'i'
  [03:00:24.530] 
  [03:00:24.531] getGlobalsAndPackages() ... DONE
  [03:00:24.532] getGlobalsAndPackages() ...
  [03:00:24.533] Searching for globals...
  [03:00:24.537] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:24.538] Searching for globals ... DONE
  [03:00:24.539] Resolving globals: FALSE
  [03:00:24.650] The total size of the 2 globals is 764.51 KiB (782856 bytes)
  [03:00:24.651] - globals: [2] 'x', 'i'
  [03:00:24.651] 
  [03:00:24.652] getGlobalsAndPackages() ... DONE
  [03:00:24.654] getGlobalsAndPackages() ...
  [03:00:24.655] Searching for globals...
  [03:00:24.659] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:24.660] Searching for globals ... DONE
  [03:00:24.660] Resolving globals: FALSE
  [03:00:24.781] The total size of the 2 globals is 772.55 KiB (791096 bytes)
  [03:00:24.781] - globals: [2] 'x', 'i'
  [03:00:24.782] 
  [03:00:24.783] getGlobalsAndPackages() ... DONE
  [03:00:24.784] getGlobalsAndPackages() ...
  [03:00:24.785] Searching for globals...
  [03:00:24.793] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [03:00:24.794] Searching for globals ... DONE
  [03:00:24.794] Resolving globals: FALSE
  [03:00:24.927] The total size of the 2 globals is 780.60 KiB (799336 bytes)
  [03:00:24.928] - globals: [2] 'x', 'i'
  [03:00:24.928] 
  [03:00:24.929] getGlobalsAndPackages() ... DONE
  
  > ## At this point nothing has been calculated,
  > ## because lazy evaluation is in place.
  > 
  > ## Get the 7:th Fibonnaci numbers (should be 8)
  > print(x[[7]])
  [03:00:24.935] Packages needed by the future expression (n = 0): <none>
  [03:00:24.936] Packages needed by future strategies (n = 0): <none>
  [03:00:24.955] {
  [03:00:24.955]     {
  [03:00:24.955]         ...future.startTime <- base::Sys.time()
  [03:00:24.955]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:24.955]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:24.955]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [03:00:24.955]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:24.955]             future.resolve.recursive = NULL, width = 80L)
  [03:00:24.955]         {
  [03:00:24.955]             {
  [03:00:24.955]                 base::local({
  [03:00:24.955]                   has_future <- base::requireNamespace("future", 
  [03:00:24.955]                     quietly = TRUE)
  [03:00:24.955]                   version <- if (has_future) 
  [03:00:24.955]                     utils::packageVersion("future")
  [03:00:24.955]                   else NULL
  [03:00:24.955]                   if (!has_future || version < "1.8.0") {
  [03:00:24.955]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:24.955]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:24.955]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:24.955]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:24.955]                         "release", "version")], collapse = " "), 
  [03:00:24.955]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:24.955]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:24.955]                       info)
  [03:00:24.955]                     info <- base::paste(info, collapse = "; ")
  [03:00:24.955]                     if (!has_future) {
  [03:00:24.955]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:24.955]                         info)
  [03:00:24.955]                     }
  [03:00:24.955]                     else {
  [03:00:24.955]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:24.955]                         info, version)
  [03:00:24.955]                     }
  [03:00:24.955]                     base::stop(msg)
  [03:00:24.955]                   }
  [03:00:24.955]                 })
  [03:00:24.955]             }
  [03:00:24.955]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:24.955]         }
  [03:00:24.955]     }
  [03:00:24.955]     if (base::is.na(NA)) {
  [03:00:24.955]     }
  [03:00:24.955]     else {
  [03:00:24.955]         if (NA) {
  [03:00:24.955]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:24.955]                 open = "w")
  [03:00:24.955]         }
  [03:00:24.955]         else {
  [03:00:24.955]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:24.955]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:24.955]         }
  [03:00:24.955]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:24.955]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:24.955]             base::sink(type = "output", split = FALSE)
  [03:00:24.955]             base::close(...future.stdout)
  [03:00:24.955]         }, add = TRUE)
  [03:00:24.955]     }
  [03:00:24.955]     ...future.frame <- base::sys.nframe()
  [03:00:24.955]     ...future.conditions <- base::list()
  [03:00:24.955]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:24.955]     ...future.result <- base::tryCatch({
  [03:00:24.955]         base::withCallingHandlers({
  [03:00:24.955]             ...future.value <- base::withVisible(base::local({
  [03:00:24.955]                 x[[i - 2]] + x[[i - 1]]
  [03:00:24.955]             }))
  [03:00:24.955]             future::FutureResult(value = ...future.value$value, 
  [03:00:24.955]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:24.955]                   ...future.rng), started = ...future.startTime, 
  [03:00:24.955]                 version = "1.8")
  [03:00:24.955]         }, condition = base::local({
  [03:00:24.955]             c <- base::c
  [03:00:24.955]             inherits <- base::inherits
  [03:00:24.955]             invokeRestart <- base::invokeRestart
  [03:00:24.955]             length <- base::length
  [03:00:24.955]             list <- base::list
  [03:00:24.955]             seq.int <- base::seq.int
  [03:00:24.955]             signalCondition <- base::signalCondition
  [03:00:24.955]             sys.calls <- base::sys.calls
  [03:00:24.955]             Sys.time <- base::Sys.time
  [03:00:24.955]             `[[` <- base::`[[`
  [03:00:24.955]             `+` <- base::`+`
  [03:00:24.955]             `<<-` <- base::`<<-`
  [03:00:24.955]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:24.955]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:24.955]                   3L)]
  [03:00:24.955]             }
  [03:00:24.955]             function(cond) {
  [03:00:24.955]                 if (inherits(cond, "error")) {
  [03:00:24.955]                   sessionInformation <- function() {
  [03:00:24.955]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:24.955]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:24.955]                       search = base::search(), system = base::Sys.info())
  [03:00:24.955]                   }
  [03:00:24.955]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:24.955]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:24.955]                     cond$call), session = sessionInformation(), 
  [03:00:24.955]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:24.955]                   signalCondition(cond)
  [03:00:24.955]                 }
  [03:00:24.955]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:24.955]                 ))) {
  [03:00:24.955]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:24.955]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:24.955]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:24.955]                   if (!signal) {
  [03:00:24.955]                     muffleCondition <- function (cond) 
  [03:00:24.955]                     {
  [03:00:24.955]                       inherits <- base::inherits
  [03:00:24.955]                       invokeRestart <- base::invokeRestart
  [03:00:24.955]                       muffled <- FALSE
  [03:00:24.955]                       if (inherits(cond, "message")) {
  [03:00:24.955]                         invokeRestart("muffleMessage")
  [03:00:24.955]                         muffled <- TRUE
  [03:00:24.955]                       }
  [03:00:24.955]                       else if (inherits(cond, "warning")) {
  [03:00:24.955]                         invokeRestart("muffleWarning")
  [03:00:24.955]                         muffled <- TRUE
  [03:00:24.955]                       }
  [03:00:24.955]                       else if (inherits(cond, "condition")) {
  [03:00:24.955]                         computeRestarts <- base::computeRestarts
  [03:00:24.955]                         grepl <- base::grepl
  [03:00:24.955]                         is.null <- base::is.null
  [03:00:24.955]                         restarts <- computeRestarts(cond)
  [03:00:24.955]                         for (restart in restarts) {
  [03:00:24.955]                           name <- restart$name
  [03:00:24.955]                           if (is.null(name)) 
  [03:00:24.955]                             next
  [03:00:24.955]                           if (!grepl("^muffle", name)) 
  [03:00:24.955]                             next
  [03:00:24.955]                           invokeRestart(restart)
  [03:00:24.955]                           muffled <- TRUE
  [03:00:24.955]                           break
  [03:00:24.955]                         }
  [03:00:24.955]                       }
  [03:00:24.955]                       invisible(muffled)
  [03:00:24.955]                     }
  [03:00:24.955]                     muffleCondition(cond)
  [03:00:24.955]                   }
  [03:00:24.955]                 }
  [03:00:24.955]             }
  [03:00:24.955]         }))
  [03:00:24.955]     }, error = function(ex) {
  [03:00:24.955]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:24.955]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:24.955]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:24.955]     }, finally = {
  [03:00:24.955]         {
  [03:00:24.955]             NULL
  [03:00:24.955]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:24.955]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:24.955]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:24.955]                 label = NULL, ...) 
  [03:00:24.955]             {
  [03:00:24.955]                 if (substitute) 
  [03:00:24.955]                   expr <- substitute(expr)
  [03:00:24.955]                 local <- as.logical(local)
  [03:00:24.955]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:24.955]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:24.955]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:24.955]                   label = label, ...)
  [03:00:24.955]                 if (!future$lazy) 
  [03:00:24.955]                   future <- run(future)
  [03:00:24.955]                 invisible(future)
  [03:00:24.955]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:24.955]         }
  [03:00:24.955]         base::options(...future.oldOptions)
  [03:00:24.955]     })
  [03:00:24.955]     Sys.time
  [03:00:24.955]     if (base::is.na(NA)) {
  [03:00:24.955]     }
  [03:00:24.955]     else {
  [03:00:24.955]         base::sink(type = "output", split = FALSE)
  [03:00:24.955]         if (NA) {
  [03:00:24.955]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:24.955]         }
  [03:00:24.955]         else {
  [03:00:24.955]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:24.955]         }
  [03:00:24.955]         base::close(...future.stdout)
  [03:00:24.955]         ...future.stdout <- NULL
  [03:00:24.955]     }
  [03:00:24.955]     ...future.result$conditions <- ...future.conditions
  [03:00:24.955]     ...future.result
  [03:00:24.955] }
  [03:00:24.963] plan(): Setting new future strategy stack:
  [03:00:24.964] List of future strategies:
  [03:00:24.964] 1. sequential:
  [03:00:24.964]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:24.964]    - tweaked: FALSE
  [03:00:24.964]    - call: NULL
  [03:00:24.965] plan(): nbrOfWorkers() = 1
  [03:00:24.969] Packages needed by the future expression (n = 0): <none>
  [03:00:24.970] Packages needed by future strategies (n = 0): <none>
  [03:00:24.977] {
  [03:00:24.977]     {
  [03:00:24.977]         ...future.startTime <- base::Sys.time()
  [03:00:24.977]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:24.977]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:24.977]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [03:00:24.977]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:24.977]             future.resolve.recursive = NULL, width = 80L)
  [03:00:24.977]         {
  [03:00:24.977]             {
  [03:00:24.977]                 base::local({
  [03:00:24.977]                   has_future <- base::requireNamespace("future", 
  [03:00:24.977]                     quietly = TRUE)
  [03:00:24.977]                   version <- if (has_future) 
  [03:00:24.977]                     utils::packageVersion("future")
  [03:00:24.977]                   else NULL
  [03:00:24.977]                   if (!has_future || version < "1.8.0") {
  [03:00:24.977]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:24.977]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:24.977]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:24.977]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:24.977]                         "release", "version")], collapse = " "), 
  [03:00:24.977]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:24.977]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:24.977]                       info)
  [03:00:24.977]                     info <- base::paste(info, collapse = "; ")
  [03:00:24.977]                     if (!has_future) {
  [03:00:24.977]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:24.977]                         info)
  [03:00:24.977]                     }
  [03:00:24.977]                     else {
  [03:00:24.977]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:24.977]                         info, version)
  [03:00:24.977]                     }
  [03:00:24.977]                     base::stop(msg)
  [03:00:24.977]                   }
  [03:00:24.977]                 })
  [03:00:24.977]             }
  [03:00:24.977]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:24.977]         }
  [03:00:24.977]     }
  [03:00:24.977]     if (base::is.na(NA)) {
  [03:00:24.977]     }
  [03:00:24.977]     else {
  [03:00:24.977]         if (NA) {
  [03:00:24.977]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:24.977]                 open = "w")
  [03:00:24.977]         }
  [03:00:24.977]         else {
  [03:00:24.977]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:24.977]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:24.977]         }
  [03:00:24.977]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:24.977]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:24.977]             base::sink(type = "output", split = FALSE)
  [03:00:24.977]             base::close(...future.stdout)
  [03:00:24.977]         }, add = TRUE)
  [03:00:24.977]     }
  [03:00:24.977]     ...future.frame <- base::sys.nframe()
  [03:00:24.977]     ...future.conditions <- base::list()
  [03:00:24.977]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:24.977]     ...future.result <- base::tryCatch({
  [03:00:24.977]         base::withCallingHandlers({
  [03:00:24.977]             ...future.value <- base::withVisible(base::local({
  [03:00:24.977]                 x[[i - 2]] + x[[i - 1]]
  [03:00:24.977]             }))
  [03:00:24.977]             future::FutureResult(value = ...future.value$value, 
  [03:00:24.977]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:24.977]                   ...future.rng), started = ...future.startTime, 
  [03:00:24.977]                 version = "1.8")
  [03:00:24.977]         }, condition = base::local({
  [03:00:24.977]             c <- base::c
  [03:00:24.977]             inherits <- base::inherits
  [03:00:24.977]             invokeRestart <- base::invokeRestart
  [03:00:24.977]             length <- base::length
  [03:00:24.977]             list <- base::list
  [03:00:24.977]             seq.int <- base::seq.int
  [03:00:24.977]             signalCondition <- base::signalCondition
  [03:00:24.977]             sys.calls <- base::sys.calls
  [03:00:24.977]             Sys.time <- base::Sys.time
  [03:00:24.977]             `[[` <- base::`[[`
  [03:00:24.977]             `+` <- base::`+`
  [03:00:24.977]             `<<-` <- base::`<<-`
  [03:00:24.977]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:24.977]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:24.977]                   3L)]
  [03:00:24.977]             }
  [03:00:24.977]             function(cond) {
  [03:00:24.977]                 if (inherits(cond, "error")) {
  [03:00:24.977]                   sessionInformation <- function() {
  [03:00:24.977]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:24.977]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:24.977]                       search = base::search(), system = base::Sys.info())
  [03:00:24.977]                   }
  [03:00:24.977]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:24.977]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:24.977]                     cond$call), session = sessionInformation(), 
  [03:00:24.977]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:24.977]                   signalCondition(cond)
  [03:00:24.977]                 }
  [03:00:24.977]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:24.977]                 ))) {
  [03:00:24.977]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:24.977]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:24.977]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:24.977]                   if (!signal) {
  [03:00:24.977]                     muffleCondition <- function (cond) 
  [03:00:24.977]                     {
  [03:00:24.977]                       inherits <- base::inherits
  [03:00:24.977]                       invokeRestart <- base::invokeRestart
  [03:00:24.977]                       muffled <- FALSE
  [03:00:24.977]                       if (inherits(cond, "message")) {
  [03:00:24.977]                         invokeRestart("muffleMessage")
  [03:00:24.977]                         muffled <- TRUE
  [03:00:24.977]                       }
  [03:00:24.977]                       else if (inherits(cond, "warning")) {
  [03:00:24.977]                         invokeRestart("muffleWarning")
  [03:00:24.977]                         muffled <- TRUE
  [03:00:24.977]                       }
  [03:00:24.977]                       else if (inherits(cond, "condition")) {
  [03:00:24.977]                         computeRestarts <- base::computeRestarts
  [03:00:24.977]                         grepl <- base::grepl
  [03:00:24.977]                         is.null <- base::is.null
  [03:00:24.977]                         restarts <- computeRestarts(cond)
  [03:00:24.977]                         for (restart in restarts) {
  [03:00:24.977]                           name <- restart$name
  [03:00:24.977]                           if (is.null(name)) 
  [03:00:24.977]                             next
  [03:00:24.977]                           if (!grepl("^muffle", name)) 
  [03:00:24.977]                             next
  [03:00:24.977]                           invokeRestart(restart)
  [03:00:24.977]                           muffled <- TRUE
  [03:00:24.977]                           break
  [03:00:24.977]                         }
  [03:00:24.977]                       }
  [03:00:24.977]                       invisible(muffled)
  [03:00:24.977]                     }
  [03:00:24.977]                     muffleCondition(cond)
  [03:00:24.977]                   }
  [03:00:24.977]                 }
  [03:00:24.977]             }
  [03:00:24.977]         }))
  [03:00:24.977]     }, error = function(ex) {
  [03:00:24.977]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:24.977]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:24.977]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:24.977]     }, finally = {
  [03:00:24.977]         {
  [03:00:24.977]             NULL
  [03:00:24.977]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:24.977]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:24.977]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:24.977]                 label = NULL, ...) 
  [03:00:24.977]             {
  [03:00:24.977]                 if (substitute) 
  [03:00:24.977]                   expr <- substitute(expr)
  [03:00:24.977]                 local <- as.logical(local)
  [03:00:24.977]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:24.977]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:24.977]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:24.977]                   label = label, ...)
  [03:00:24.977]                 if (!future$lazy) 
  [03:00:24.977]                   future <- run(future)
  [03:00:24.977]                 invisible(future)
  [03:00:24.977]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:24.977]         }
  [03:00:24.977]         base::options(...future.oldOptions)
  [03:00:24.977]     })
  [03:00:24.977]     Sys.time
  [03:00:24.977]     if (base::is.na(NA)) {
  [03:00:24.977]     }
  [03:00:24.977]     else {
  [03:00:24.977]         base::sink(type = "output", split = FALSE)
  [03:00:24.977]         if (NA) {
  [03:00:24.977]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:24.977]         }
  [03:00:24.977]         else {
  [03:00:24.977]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:24.977]         }
  [03:00:24.977]         base::close(...future.stdout)
  [03:00:24.977]         ...future.stdout <- NULL
  [03:00:24.977]     }
  [03:00:24.977]     ...future.result$conditions <- ...future.conditions
  [03:00:24.977]     ...future.result
  [03:00:24.977] }
  [03:00:24.985] plan(): Setting new future strategy stack:
  [03:00:24.985] List of future strategies:
  [03:00:24.985] 1. sequential:
  [03:00:24.985]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:24.985]    - tweaked: FALSE
  [03:00:24.985]    - call: NULL
  [03:00:24.987] plan(): nbrOfWorkers() = 1
  [03:00:24.990] Packages needed by the future expression (n = 0): <none>
  [03:00:24.991] Packages needed by future strategies (n = 0): <none>
  [03:00:25.001] {
  [03:00:25.001]     {
  [03:00:25.001]         ...future.startTime <- base::Sys.time()
  [03:00:25.001]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.001]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.001]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [03:00:25.001]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.001]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.001]         {
  [03:00:25.001]             {
  [03:00:25.001]                 base::local({
  [03:00:25.001]                   has_future <- base::requireNamespace("future", 
  [03:00:25.001]                     quietly = TRUE)
  [03:00:25.001]                   version <- if (has_future) 
  [03:00:25.001]                     utils::packageVersion("future")
  [03:00:25.001]                   else NULL
  [03:00:25.001]                   if (!has_future || version < "1.8.0") {
  [03:00:25.001]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.001]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.001]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.001]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.001]                         "release", "version")], collapse = " "), 
  [03:00:25.001]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.001]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.001]                       info)
  [03:00:25.001]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.001]                     if (!has_future) {
  [03:00:25.001]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.001]                         info)
  [03:00:25.001]                     }
  [03:00:25.001]                     else {
  [03:00:25.001]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.001]                         info, version)
  [03:00:25.001]                     }
  [03:00:25.001]                     base::stop(msg)
  [03:00:25.001]                   }
  [03:00:25.001]                 })
  [03:00:25.001]             }
  [03:00:25.001]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.001]         }
  [03:00:25.001]     }
  [03:00:25.001]     if (base::is.na(NA)) {
  [03:00:25.001]     }
  [03:00:25.001]     else {
  [03:00:25.001]         if (NA) {
  [03:00:25.001]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.001]                 open = "w")
  [03:00:25.001]         }
  [03:00:25.001]         else {
  [03:00:25.001]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.001]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.001]         }
  [03:00:25.001]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.001]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.001]             base::sink(type = "output", split = FALSE)
  [03:00:25.001]             base::close(...future.stdout)
  [03:00:25.001]         }, add = TRUE)
  [03:00:25.001]     }
  [03:00:25.001]     ...future.frame <- base::sys.nframe()
  [03:00:25.001]     ...future.conditions <- base::list()
  [03:00:25.001]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.001]     ...future.result <- base::tryCatch({
  [03:00:25.001]         base::withCallingHandlers({
  [03:00:25.001]             ...future.value <- base::withVisible(base::local({
  [03:00:25.001]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.001]             }))
  [03:00:25.001]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.001]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.001]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.001]                 version = "1.8")
  [03:00:25.001]         }, condition = base::local({
  [03:00:25.001]             c <- base::c
  [03:00:25.001]             inherits <- base::inherits
  [03:00:25.001]             invokeRestart <- base::invokeRestart
  [03:00:25.001]             length <- base::length
  [03:00:25.001]             list <- base::list
  [03:00:25.001]             seq.int <- base::seq.int
  [03:00:25.001]             signalCondition <- base::signalCondition
  [03:00:25.001]             sys.calls <- base::sys.calls
  [03:00:25.001]             Sys.time <- base::Sys.time
  [03:00:25.001]             `[[` <- base::`[[`
  [03:00:25.001]             `+` <- base::`+`
  [03:00:25.001]             `<<-` <- base::`<<-`
  [03:00:25.001]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.001]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.001]                   3L)]
  [03:00:25.001]             }
  [03:00:25.001]             function(cond) {
  [03:00:25.001]                 if (inherits(cond, "error")) {
  [03:00:25.001]                   sessionInformation <- function() {
  [03:00:25.001]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.001]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.001]                       search = base::search(), system = base::Sys.info())
  [03:00:25.001]                   }
  [03:00:25.001]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.001]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.001]                     cond$call), session = sessionInformation(), 
  [03:00:25.001]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.001]                   signalCondition(cond)
  [03:00:25.001]                 }
  [03:00:25.001]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.001]                 ))) {
  [03:00:25.001]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.001]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.001]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.001]                   if (!signal) {
  [03:00:25.001]                     muffleCondition <- function (cond) 
  [03:00:25.001]                     {
  [03:00:25.001]                       inherits <- base::inherits
  [03:00:25.001]                       invokeRestart <- base::invokeRestart
  [03:00:25.001]                       muffled <- FALSE
  [03:00:25.001]                       if (inherits(cond, "message")) {
  [03:00:25.001]                         invokeRestart("muffleMessage")
  [03:00:25.001]                         muffled <- TRUE
  [03:00:25.001]                       }
  [03:00:25.001]                       else if (inherits(cond, "warning")) {
  [03:00:25.001]                         invokeRestart("muffleWarning")
  [03:00:25.001]                         muffled <- TRUE
  [03:00:25.001]                       }
  [03:00:25.001]                       else if (inherits(cond, "condition")) {
  [03:00:25.001]                         computeRestarts <- base::computeRestarts
  [03:00:25.001]                         grepl <- base::grepl
  [03:00:25.001]                         is.null <- base::is.null
  [03:00:25.001]                         restarts <- computeRestarts(cond)
  [03:00:25.001]                         for (restart in restarts) {
  [03:00:25.001]                           name <- restart$name
  [03:00:25.001]                           if (is.null(name)) 
  [03:00:25.001]                             next
  [03:00:25.001]                           if (!grepl("^muffle", name)) 
  [03:00:25.001]                             next
  [03:00:25.001]                           invokeRestart(restart)
  [03:00:25.001]                           muffled <- TRUE
  [03:00:25.001]                           break
  [03:00:25.001]                         }
  [03:00:25.001]                       }
  [03:00:25.001]                       invisible(muffled)
  [03:00:25.001]                     }
  [03:00:25.001]                     muffleCondition(cond)
  [03:00:25.001]                   }
  [03:00:25.001]                 }
  [03:00:25.001]             }
  [03:00:25.001]         }))
  [03:00:25.001]     }, error = function(ex) {
  [03:00:25.001]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.001]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.001]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.001]     }, finally = {
  [03:00:25.001]         {
  [03:00:25.001]             NULL
  [03:00:25.001]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.001]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.001]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.001]                 label = NULL, ...) 
  [03:00:25.001]             {
  [03:00:25.001]                 if (substitute) 
  [03:00:25.001]                   expr <- substitute(expr)
  [03:00:25.001]                 local <- as.logical(local)
  [03:00:25.001]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.001]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.001]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.001]                   label = label, ...)
  [03:00:25.001]                 if (!future$lazy) 
  [03:00:25.001]                   future <- run(future)
  [03:00:25.001]                 invisible(future)
  [03:00:25.001]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.001]         }
  [03:00:25.001]         base::options(...future.oldOptions)
  [03:00:25.001]     })
  [03:00:25.001]     Sys.time
  [03:00:25.001]     if (base::is.na(NA)) {
  [03:00:25.001]     }
  [03:00:25.001]     else {
  [03:00:25.001]         base::sink(type = "output", split = FALSE)
  [03:00:25.001]         if (NA) {
  [03:00:25.001]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.001]         }
  [03:00:25.001]         else {
  [03:00:25.001]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.001]         }
  [03:00:25.001]         base::close(...future.stdout)
  [03:00:25.001]         ...future.stdout <- NULL
  [03:00:25.001]     }
  [03:00:25.001]     ...future.result$conditions <- ...future.conditions
  [03:00:25.001]     ...future.result
  [03:00:25.001] }
  [03:00:25.008] plan(): Setting new future strategy stack:
  [03:00:25.009] List of future strategies:
  [03:00:25.009] 1. sequential:
  [03:00:25.009]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.009]    - tweaked: FALSE
  [03:00:25.009]    - call: NULL
  [03:00:25.011] plan(): nbrOfWorkers() = 1
  [03:00:25.013] plan(): Setting new future strategy stack:
  [03:00:25.014] List of future strategies:
  [03:00:25.014] 1. sequential:
  [03:00:25.014]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.014]    - tweaked: FALSE
  [03:00:25.014]    - call: NULL
  [03:00:25.016] plan(): nbrOfWorkers() = 1
  [03:00:25.017] SequentialFuture started (and completed)
  [03:00:25.021] Packages needed by the future expression (n = 0): <none>
  [03:00:25.022] Packages needed by future strategies (n = 0): <none>
  [03:00:25.030] {
  [03:00:25.030]     {
  [03:00:25.030]         ...future.startTime <- base::Sys.time()
  [03:00:25.030]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.030]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.030]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.030]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.030]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.030]         {
  [03:00:25.030]             {
  [03:00:25.030]                 base::local({
  [03:00:25.030]                   has_future <- base::requireNamespace("future", 
  [03:00:25.030]                     quietly = TRUE)
  [03:00:25.030]                   version <- if (has_future) 
  [03:00:25.030]                     utils::packageVersion("future")
  [03:00:25.030]                   else NULL
  [03:00:25.030]                   if (!has_future || version < "1.8.0") {
  [03:00:25.030]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.030]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.030]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.030]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.030]                         "release", "version")], collapse = " "), 
  [03:00:25.030]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.030]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.030]                       info)
  [03:00:25.030]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.030]                     if (!has_future) {
  [03:00:25.030]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.030]                         info)
  [03:00:25.030]                     }
  [03:00:25.030]                     else {
  [03:00:25.030]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.030]                         info, version)
  [03:00:25.030]                     }
  [03:00:25.030]                     base::stop(msg)
  [03:00:25.030]                   }
  [03:00:25.030]                 })
  [03:00:25.030]             }
  [03:00:25.030]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.030]         }
  [03:00:25.030]     }
  [03:00:25.030]     if (base::is.na(NA)) {
  [03:00:25.030]     }
  [03:00:25.030]     else {
  [03:00:25.030]         if (NA) {
  [03:00:25.030]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.030]                 open = "w")
  [03:00:25.030]         }
  [03:00:25.030]         else {
  [03:00:25.030]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.030]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.030]         }
  [03:00:25.030]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.030]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.030]             base::sink(type = "output", split = FALSE)
  [03:00:25.030]             base::close(...future.stdout)
  [03:00:25.030]         }, add = TRUE)
  [03:00:25.030]     }
  [03:00:25.030]     ...future.frame <- base::sys.nframe()
  [03:00:25.030]     ...future.conditions <- base::list()
  [03:00:25.030]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.030]     ...future.result <- base::tryCatch({
  [03:00:25.030]         base::withCallingHandlers({
  [03:00:25.030]             ...future.value <- base::withVisible(base::local({
  [03:00:25.030]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.030]             }))
  [03:00:25.030]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.030]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.030]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.030]                 version = "1.8")
  [03:00:25.030]         }, condition = base::local({
  [03:00:25.030]             c <- base::c
  [03:00:25.030]             inherits <- base::inherits
  [03:00:25.030]             invokeRestart <- base::invokeRestart
  [03:00:25.030]             length <- base::length
  [03:00:25.030]             list <- base::list
  [03:00:25.030]             seq.int <- base::seq.int
  [03:00:25.030]             signalCondition <- base::signalCondition
  [03:00:25.030]             sys.calls <- base::sys.calls
  [03:00:25.030]             Sys.time <- base::Sys.time
  [03:00:25.030]             `[[` <- base::`[[`
  [03:00:25.030]             `+` <- base::`+`
  [03:00:25.030]             `<<-` <- base::`<<-`
  [03:00:25.030]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.030]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.030]                   3L)]
  [03:00:25.030]             }
  [03:00:25.030]             function(cond) {
  [03:00:25.030]                 if (inherits(cond, "error")) {
  [03:00:25.030]                   sessionInformation <- function() {
  [03:00:25.030]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.030]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.030]                       search = base::search(), system = base::Sys.info())
  [03:00:25.030]                   }
  [03:00:25.030]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.030]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.030]                     cond$call), session = sessionInformation(), 
  [03:00:25.030]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.030]                   signalCondition(cond)
  [03:00:25.030]                 }
  [03:00:25.030]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.030]                 ))) {
  [03:00:25.030]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.030]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.030]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.030]                   if (!signal) {
  [03:00:25.030]                     muffleCondition <- function (cond) 
  [03:00:25.030]                     {
  [03:00:25.030]                       inherits <- base::inherits
  [03:00:25.030]                       invokeRestart <- base::invokeRestart
  [03:00:25.030]                       muffled <- FALSE
  [03:00:25.030]                       if (inherits(cond, "message")) {
  [03:00:25.030]                         invokeRestart("muffleMessage")
  [03:00:25.030]                         muffled <- TRUE
  [03:00:25.030]                       }
  [03:00:25.030]                       else if (inherits(cond, "warning")) {
  [03:00:25.030]                         invokeRestart("muffleWarning")
  [03:00:25.030]                         muffled <- TRUE
  [03:00:25.030]                       }
  [03:00:25.030]                       else if (inherits(cond, "condition")) {
  [03:00:25.030]                         computeRestarts <- base::computeRestarts
  [03:00:25.030]                         grepl <- base::grepl
  [03:00:25.030]                         is.null <- base::is.null
  [03:00:25.030]                         restarts <- computeRestarts(cond)
  [03:00:25.030]                         for (restart in restarts) {
  [03:00:25.030]                           name <- restart$name
  [03:00:25.030]                           if (is.null(name)) 
  [03:00:25.030]                             next
  [03:00:25.030]                           if (!grepl("^muffle", name)) 
  [03:00:25.030]                             next
  [03:00:25.030]                           invokeRestart(restart)
  [03:00:25.030]                           muffled <- TRUE
  [03:00:25.030]                           break
  [03:00:25.030]                         }
  [03:00:25.030]                       }
  [03:00:25.030]                       invisible(muffled)
  [03:00:25.030]                     }
  [03:00:25.030]                     muffleCondition(cond)
  [03:00:25.030]                   }
  [03:00:25.030]                 }
  [03:00:25.030]             }
  [03:00:25.030]         }))
  [03:00:25.030]     }, error = function(ex) {
  [03:00:25.030]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.030]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.030]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.030]     }, finally = {
  [03:00:25.030]         {
  [03:00:25.030]             NULL
  [03:00:25.030]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.030]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.030]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.030]                 label = NULL, ...) 
  [03:00:25.030]             {
  [03:00:25.030]                 if (substitute) 
  [03:00:25.030]                   expr <- substitute(expr)
  [03:00:25.030]                 local <- as.logical(local)
  [03:00:25.030]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.030]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.030]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.030]                   label = label, ...)
  [03:00:25.030]                 if (!future$lazy) 
  [03:00:25.030]                   future <- run(future)
  [03:00:25.030]                 invisible(future)
  [03:00:25.030]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.030]         }
  [03:00:25.030]         base::options(...future.oldOptions)
  [03:00:25.030]     })
  [03:00:25.030]     Sys.time
  [03:00:25.030]     if (base::is.na(NA)) {
  [03:00:25.030]     }
  [03:00:25.030]     else {
  [03:00:25.030]         base::sink(type = "output", split = FALSE)
  [03:00:25.030]         if (NA) {
  [03:00:25.030]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.030]         }
  [03:00:25.030]         else {
  [03:00:25.030]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.030]         }
  [03:00:25.030]         base::close(...future.stdout)
  [03:00:25.030]         ...future.stdout <- NULL
  [03:00:25.030]     }
  [03:00:25.030]     ...future.result$conditions <- ...future.conditions
  [03:00:25.030]     ...future.result
  [03:00:25.030] }
  [03:00:25.037] plan(): Setting new future strategy stack:
  [03:00:25.038] List of future strategies:
  [03:00:25.038] 1. sequential:
  [03:00:25.038]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.038]    - tweaked: FALSE
  [03:00:25.038]    - call: NULL
  [03:00:25.039] plan(): nbrOfWorkers() = 1
  [03:00:25.041] plan(): Setting new future strategy stack:
  [03:00:25.042] List of future strategies:
  [03:00:25.042] 1. sequential:
  [03:00:25.042]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.042]    - tweaked: FALSE
  [03:00:25.042]    - call: NULL
  [03:00:25.044] plan(): nbrOfWorkers() = 1
  [03:00:25.045] SequentialFuture started (and completed)
  [03:00:25.046] plan(): Setting new future strategy stack:
  [03:00:25.047] List of future strategies:
  [03:00:25.047] 1. sequential:
  [03:00:25.047]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.047]    - tweaked: FALSE
  [03:00:25.047]    - call: NULL
  [03:00:25.048] plan(): nbrOfWorkers() = 1
  [03:00:25.049] SequentialFuture started (and completed)
  [03:00:25.052] Packages needed by the future expression (n = 0): <none>
  [03:00:25.053] Packages needed by future strategies (n = 0): <none>
  [03:00:25.060] {
  [03:00:25.060]     {
  [03:00:25.060]         ...future.startTime <- base::Sys.time()
  [03:00:25.060]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.060]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.060]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.060]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.060]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.060]         {
  [03:00:25.060]             {
  [03:00:25.060]                 base::local({
  [03:00:25.060]                   has_future <- base::requireNamespace("future", 
  [03:00:25.060]                     quietly = TRUE)
  [03:00:25.060]                   version <- if (has_future) 
  [03:00:25.060]                     utils::packageVersion("future")
  [03:00:25.060]                   else NULL
  [03:00:25.060]                   if (!has_future || version < "1.8.0") {
  [03:00:25.060]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.060]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.060]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.060]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.060]                         "release", "version")], collapse = " "), 
  [03:00:25.060]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.060]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.060]                       info)
  [03:00:25.060]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.060]                     if (!has_future) {
  [03:00:25.060]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.060]                         info)
  [03:00:25.060]                     }
  [03:00:25.060]                     else {
  [03:00:25.060]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.060]                         info, version)
  [03:00:25.060]                     }
  [03:00:25.060]                     base::stop(msg)
  [03:00:25.060]                   }
  [03:00:25.060]                 })
  [03:00:25.060]             }
  [03:00:25.060]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.060]         }
  [03:00:25.060]     }
  [03:00:25.060]     if (base::is.na(NA)) {
  [03:00:25.060]     }
  [03:00:25.060]     else {
  [03:00:25.060]         if (NA) {
  [03:00:25.060]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.060]                 open = "w")
  [03:00:25.060]         }
  [03:00:25.060]         else {
  [03:00:25.060]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.060]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.060]         }
  [03:00:25.060]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.060]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.060]             base::sink(type = "output", split = FALSE)
  [03:00:25.060]             base::close(...future.stdout)
  [03:00:25.060]         }, add = TRUE)
  [03:00:25.060]     }
  [03:00:25.060]     ...future.frame <- base::sys.nframe()
  [03:00:25.060]     ...future.conditions <- base::list()
  [03:00:25.060]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.060]     ...future.result <- base::tryCatch({
  [03:00:25.060]         base::withCallingHandlers({
  [03:00:25.060]             ...future.value <- base::withVisible(base::local({
  [03:00:25.060]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.060]             }))
  [03:00:25.060]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.060]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.060]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.060]                 version = "1.8")
  [03:00:25.060]         }, condition = base::local({
  [03:00:25.060]             c <- base::c
  [03:00:25.060]             inherits <- base::inherits
  [03:00:25.060]             invokeRestart <- base::invokeRestart
  [03:00:25.060]             length <- base::length
  [03:00:25.060]             list <- base::list
  [03:00:25.060]             seq.int <- base::seq.int
  [03:00:25.060]             signalCondition <- base::signalCondition
  [03:00:25.060]             sys.calls <- base::sys.calls
  [03:00:25.060]             Sys.time <- base::Sys.time
  [03:00:25.060]             `[[` <- base::`[[`
  [03:00:25.060]             `+` <- base::`+`
  [03:00:25.060]             `<<-` <- base::`<<-`
  [03:00:25.060]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.060]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.060]                   3L)]
  [03:00:25.060]             }
  [03:00:25.060]             function(cond) {
  [03:00:25.060]                 if (inherits(cond, "error")) {
  [03:00:25.060]                   sessionInformation <- function() {
  [03:00:25.060]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.060]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.060]                       search = base::search(), system = base::Sys.info())
  [03:00:25.060]                   }
  [03:00:25.060]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.060]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.060]                     cond$call), session = sessionInformation(), 
  [03:00:25.060]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.060]                   signalCondition(cond)
  [03:00:25.060]                 }
  [03:00:25.060]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.060]                 ))) {
  [03:00:25.060]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.060]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.060]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.060]                   if (!signal) {
  [03:00:25.060]                     muffleCondition <- function (cond) 
  [03:00:25.060]                     {
  [03:00:25.060]                       inherits <- base::inherits
  [03:00:25.060]                       invokeRestart <- base::invokeRestart
  [03:00:25.060]                       muffled <- FALSE
  [03:00:25.060]                       if (inherits(cond, "message")) {
  [03:00:25.060]                         invokeRestart("muffleMessage")
  [03:00:25.060]                         muffled <- TRUE
  [03:00:25.060]                       }
  [03:00:25.060]                       else if (inherits(cond, "warning")) {
  [03:00:25.060]                         invokeRestart("muffleWarning")
  [03:00:25.060]                         muffled <- TRUE
  [03:00:25.060]                       }
  [03:00:25.060]                       else if (inherits(cond, "condition")) {
  [03:00:25.060]                         computeRestarts <- base::computeRestarts
  [03:00:25.060]                         grepl <- base::grepl
  [03:00:25.060]                         is.null <- base::is.null
  [03:00:25.060]                         restarts <- computeRestarts(cond)
  [03:00:25.060]                         for (restart in restarts) {
  [03:00:25.060]                           name <- restart$name
  [03:00:25.060]                           if (is.null(name)) 
  [03:00:25.060]                             next
  [03:00:25.060]                           if (!grepl("^muffle", name)) 
  [03:00:25.060]                             next
  [03:00:25.060]                           invokeRestart(restart)
  [03:00:25.060]                           muffled <- TRUE
  [03:00:25.060]                           break
  [03:00:25.060]                         }
  [03:00:25.060]                       }
  [03:00:25.060]                       invisible(muffled)
  [03:00:25.060]                     }
  [03:00:25.060]                     muffleCondition(cond)
  [03:00:25.060]                   }
  [03:00:25.060]                 }
  [03:00:25.060]             }
  [03:00:25.060]         }))
  [03:00:25.060]     }, error = function(ex) {
  [03:00:25.060]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.060]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.060]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.060]     }, finally = {
  [03:00:25.060]         {
  [03:00:25.060]             NULL
  [03:00:25.060]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.060]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.060]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.060]                 label = NULL, ...) 
  [03:00:25.060]             {
  [03:00:25.060]                 if (substitute) 
  [03:00:25.060]                   expr <- substitute(expr)
  [03:00:25.060]                 local <- as.logical(local)
  [03:00:25.060]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.060]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.060]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.060]                   label = label, ...)
  [03:00:25.060]                 if (!future$lazy) 
  [03:00:25.060]                   future <- run(future)
  [03:00:25.060]                 invisible(future)
  [03:00:25.060]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.060]         }
  [03:00:25.060]         base::options(...future.oldOptions)
  [03:00:25.060]     })
  [03:00:25.060]     Sys.time
  [03:00:25.060]     if (base::is.na(NA)) {
  [03:00:25.060]     }
  [03:00:25.060]     else {
  [03:00:25.060]         base::sink(type = "output", split = FALSE)
  [03:00:25.060]         if (NA) {
  [03:00:25.060]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.060]         }
  [03:00:25.060]         else {
  [03:00:25.060]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.060]         }
  [03:00:25.060]         base::close(...future.stdout)
  [03:00:25.060]         ...future.stdout <- NULL
  [03:00:25.060]     }
  [03:00:25.060]     ...future.result$conditions <- ...future.conditions
  [03:00:25.060]     ...future.result
  [03:00:25.060] }
  [03:00:25.072] plan(): Setting new future strategy stack:
  [03:00:25.072] List of future strategies:
  [03:00:25.072] 1. sequential:
  [03:00:25.072]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.072]    - tweaked: FALSE
  [03:00:25.072]    - call: NULL
  [03:00:25.074] plan(): nbrOfWorkers() = 1
  [03:00:25.076] plan(): Setting new future strategy stack:
  [03:00:25.076] List of future strategies:
  [03:00:25.076] 1. sequential:
  [03:00:25.076]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.076]    - tweaked: FALSE
  [03:00:25.076]    - call: NULL
  [03:00:25.078] plan(): nbrOfWorkers() = 1
  [03:00:25.079] SequentialFuture started (and completed)
  [03:00:25.080] plan(): Setting new future strategy stack:
  [03:00:25.081] List of future strategies:
  [03:00:25.081] 1. sequential:
  [03:00:25.081]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.081]    - tweaked: FALSE
  [03:00:25.081]    - call: plan(sequential)
  [03:00:25.082] plan(): nbrOfWorkers() = 1
  [03:00:25.083] SequentialFuture started (and completed)
  [1] 8
  
  > ## At this point x[1:7] have been calculated,
  > ## but nothing beyond.
  > 
  > ## Let's get the 50:th number.
  > print(x[[50]])
  [03:00:25.087] Packages needed by the future expression (n = 0): <none>
  [03:00:25.087] Packages needed by future strategies (n = 0): <none>
  [03:00:25.095] {
  [03:00:25.095]     {
  [03:00:25.095]         ...future.startTime <- base::Sys.time()
  [03:00:25.095]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.095]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.095]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.095]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.095]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.095]         {
  [03:00:25.095]             {
  [03:00:25.095]                 base::local({
  [03:00:25.095]                   has_future <- base::requireNamespace("future", 
  [03:00:25.095]                     quietly = TRUE)
  [03:00:25.095]                   version <- if (has_future) 
  [03:00:25.095]                     utils::packageVersion("future")
  [03:00:25.095]                   else NULL
  [03:00:25.095]                   if (!has_future || version < "1.8.0") {
  [03:00:25.095]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.095]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.095]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.095]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.095]                         "release", "version")], collapse = " "), 
  [03:00:25.095]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.095]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.095]                       info)
  [03:00:25.095]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.095]                     if (!has_future) {
  [03:00:25.095]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.095]                         info)
  [03:00:25.095]                     }
  [03:00:25.095]                     else {
  [03:00:25.095]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.095]                         info, version)
  [03:00:25.095]                     }
  [03:00:25.095]                     base::stop(msg)
  [03:00:25.095]                   }
  [03:00:25.095]                 })
  [03:00:25.095]             }
  [03:00:25.095]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.095]         }
  [03:00:25.095]     }
  [03:00:25.095]     if (base::is.na(NA)) {
  [03:00:25.095]     }
  [03:00:25.095]     else {
  [03:00:25.095]         if (NA) {
  [03:00:25.095]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.095]                 open = "w")
  [03:00:25.095]         }
  [03:00:25.095]         else {
  [03:00:25.095]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.095]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.095]         }
  [03:00:25.095]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.095]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.095]             base::sink(type = "output", split = FALSE)
  [03:00:25.095]             base::close(...future.stdout)
  [03:00:25.095]         }, add = TRUE)
  [03:00:25.095]     }
  [03:00:25.095]     ...future.frame <- base::sys.nframe()
  [03:00:25.095]     ...future.conditions <- base::list()
  [03:00:25.095]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.095]     ...future.result <- base::tryCatch({
  [03:00:25.095]         base::withCallingHandlers({
  [03:00:25.095]             ...future.value <- base::withVisible(base::local({
  [03:00:25.095]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.095]             }))
  [03:00:25.095]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.095]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.095]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.095]                 version = "1.8")
  [03:00:25.095]         }, condition = base::local({
  [03:00:25.095]             c <- base::c
  [03:00:25.095]             inherits <- base::inherits
  [03:00:25.095]             invokeRestart <- base::invokeRestart
  [03:00:25.095]             length <- base::length
  [03:00:25.095]             list <- base::list
  [03:00:25.095]             seq.int <- base::seq.int
  [03:00:25.095]             signalCondition <- base::signalCondition
  [03:00:25.095]             sys.calls <- base::sys.calls
  [03:00:25.095]             Sys.time <- base::Sys.time
  [03:00:25.095]             `[[` <- base::`[[`
  [03:00:25.095]             `+` <- base::`+`
  [03:00:25.095]             `<<-` <- base::`<<-`
  [03:00:25.095]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.095]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.095]                   3L)]
  [03:00:25.095]             }
  [03:00:25.095]             function(cond) {
  [03:00:25.095]                 if (inherits(cond, "error")) {
  [03:00:25.095]                   sessionInformation <- function() {
  [03:00:25.095]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.095]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.095]                       search = base::search(), system = base::Sys.info())
  [03:00:25.095]                   }
  [03:00:25.095]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.095]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.095]                     cond$call), session = sessionInformation(), 
  [03:00:25.095]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.095]                   signalCondition(cond)
  [03:00:25.095]                 }
  [03:00:25.095]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.095]                 ))) {
  [03:00:25.095]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.095]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.095]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.095]                   if (!signal) {
  [03:00:25.095]                     muffleCondition <- function (cond) 
  [03:00:25.095]                     {
  [03:00:25.095]                       inherits <- base::inherits
  [03:00:25.095]                       invokeRestart <- base::invokeRestart
  [03:00:25.095]                       muffled <- FALSE
  [03:00:25.095]                       if (inherits(cond, "message")) {
  [03:00:25.095]                         invokeRestart("muffleMessage")
  [03:00:25.095]                         muffled <- TRUE
  [03:00:25.095]                       }
  [03:00:25.095]                       else if (inherits(cond, "warning")) {
  [03:00:25.095]                         invokeRestart("muffleWarning")
  [03:00:25.095]                         muffled <- TRUE
  [03:00:25.095]                       }
  [03:00:25.095]                       else if (inherits(cond, "condition")) {
  [03:00:25.095]                         computeRestarts <- base::computeRestarts
  [03:00:25.095]                         grepl <- base::grepl
  [03:00:25.095]                         is.null <- base::is.null
  [03:00:25.095]                         restarts <- computeRestarts(cond)
  [03:00:25.095]                         for (restart in restarts) {
  [03:00:25.095]                           name <- restart$name
  [03:00:25.095]                           if (is.null(name)) 
  [03:00:25.095]                             next
  [03:00:25.095]                           if (!grepl("^muffle", name)) 
  [03:00:25.095]                             next
  [03:00:25.095]                           invokeRestart(restart)
  [03:00:25.095]                           muffled <- TRUE
  [03:00:25.095]                           break
  [03:00:25.095]                         }
  [03:00:25.095]                       }
  [03:00:25.095]                       invisible(muffled)
  [03:00:25.095]                     }
  [03:00:25.095]                     muffleCondition(cond)
  [03:00:25.095]                   }
  [03:00:25.095]                 }
  [03:00:25.095]             }
  [03:00:25.095]         }))
  [03:00:25.095]     }, error = function(ex) {
  [03:00:25.095]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.095]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.095]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.095]     }, finally = {
  [03:00:25.095]         {
  [03:00:25.095]             NULL
  [03:00:25.095]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.095]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.095]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.095]                 label = NULL, ...) 
  [03:00:25.095]             {
  [03:00:25.095]                 if (substitute) 
  [03:00:25.095]                   expr <- substitute(expr)
  [03:00:25.095]                 local <- as.logical(local)
  [03:00:25.095]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.095]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.095]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.095]                   label = label, ...)
  [03:00:25.095]                 if (!future$lazy) 
  [03:00:25.095]                   future <- run(future)
  [03:00:25.095]                 invisible(future)
  [03:00:25.095]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.095]         }
  [03:00:25.095]         base::options(...future.oldOptions)
  [03:00:25.095]     })
  [03:00:25.095]     Sys.time
  [03:00:25.095]     if (base::is.na(NA)) {
  [03:00:25.095]     }
  [03:00:25.095]     else {
  [03:00:25.095]         base::sink(type = "output", split = FALSE)
  [03:00:25.095]         if (NA) {
  [03:00:25.095]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.095]         }
  [03:00:25.095]         else {
  [03:00:25.095]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.095]         }
  [03:00:25.095]         base::close(...future.stdout)
  [03:00:25.095]         ...future.stdout <- NULL
  [03:00:25.095]     }
  [03:00:25.095]     ...future.result$conditions <- ...future.conditions
  [03:00:25.095]     ...future.result
  [03:00:25.095] }
  [03:00:25.102] plan(): Setting new future strategy stack:
  [03:00:25.103] List of future strategies:
  [03:00:25.103] 1. sequential:
  [03:00:25.103]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.103]    - tweaked: FALSE
  [03:00:25.103]    - call: NULL
  [03:00:25.104] plan(): nbrOfWorkers() = 1
  [03:00:25.108] Packages needed by the future expression (n = 0): <none>
  [03:00:25.108] Packages needed by future strategies (n = 0): <none>
  [03:00:25.117] {
  [03:00:25.117]     {
  [03:00:25.117]         ...future.startTime <- base::Sys.time()
  [03:00:25.117]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.117]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.117]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.117]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.117]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.117]         {
  [03:00:25.117]             {
  [03:00:25.117]                 base::local({
  [03:00:25.117]                   has_future <- base::requireNamespace("future", 
  [03:00:25.117]                     quietly = TRUE)
  [03:00:25.117]                   version <- if (has_future) 
  [03:00:25.117]                     utils::packageVersion("future")
  [03:00:25.117]                   else NULL
  [03:00:25.117]                   if (!has_future || version < "1.8.0") {
  [03:00:25.117]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.117]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.117]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.117]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.117]                         "release", "version")], collapse = " "), 
  [03:00:25.117]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.117]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.117]                       info)
  [03:00:25.117]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.117]                     if (!has_future) {
  [03:00:25.117]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.117]                         info)
  [03:00:25.117]                     }
  [03:00:25.117]                     else {
  [03:00:25.117]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.117]                         info, version)
  [03:00:25.117]                     }
  [03:00:25.117]                     base::stop(msg)
  [03:00:25.117]                   }
  [03:00:25.117]                 })
  [03:00:25.117]             }
  [03:00:25.117]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.117]         }
  [03:00:25.117]     }
  [03:00:25.117]     if (base::is.na(NA)) {
  [03:00:25.117]     }
  [03:00:25.117]     else {
  [03:00:25.117]         if (NA) {
  [03:00:25.117]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.117]                 open = "w")
  [03:00:25.117]         }
  [03:00:25.117]         else {
  [03:00:25.117]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.117]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.117]         }
  [03:00:25.117]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.117]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.117]             base::sink(type = "output", split = FALSE)
  [03:00:25.117]             base::close(...future.stdout)
  [03:00:25.117]         }, add = TRUE)
  [03:00:25.117]     }
  [03:00:25.117]     ...future.frame <- base::sys.nframe()
  [03:00:25.117]     ...future.conditions <- base::list()
  [03:00:25.117]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.117]     ...future.result <- base::tryCatch({
  [03:00:25.117]         base::withCallingHandlers({
  [03:00:25.117]             ...future.value <- base::withVisible(base::local({
  [03:00:25.117]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.117]             }))
  [03:00:25.117]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.117]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.117]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.117]                 version = "1.8")
  [03:00:25.117]         }, condition = base::local({
  [03:00:25.117]             c <- base::c
  [03:00:25.117]             inherits <- base::inherits
  [03:00:25.117]             invokeRestart <- base::invokeRestart
  [03:00:25.117]             length <- base::length
  [03:00:25.117]             list <- base::list
  [03:00:25.117]             seq.int <- base::seq.int
  [03:00:25.117]             signalCondition <- base::signalCondition
  [03:00:25.117]             sys.calls <- base::sys.calls
  [03:00:25.117]             Sys.time <- base::Sys.time
  [03:00:25.117]             `[[` <- base::`[[`
  [03:00:25.117]             `+` <- base::`+`
  [03:00:25.117]             `<<-` <- base::`<<-`
  [03:00:25.117]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.117]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.117]                   3L)]
  [03:00:25.117]             }
  [03:00:25.117]             function(cond) {
  [03:00:25.117]                 if (inherits(cond, "error")) {
  [03:00:25.117]                   sessionInformation <- function() {
  [03:00:25.117]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.117]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.117]                       search = base::search(), system = base::Sys.info())
  [03:00:25.117]                   }
  [03:00:25.117]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.117]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.117]                     cond$call), session = sessionInformation(), 
  [03:00:25.117]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.117]                   signalCondition(cond)
  [03:00:25.117]                 }
  [03:00:25.117]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.117]                 ))) {
  [03:00:25.117]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.117]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.117]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.117]                   if (!signal) {
  [03:00:25.117]                     muffleCondition <- function (cond) 
  [03:00:25.117]                     {
  [03:00:25.117]                       inherits <- base::inherits
  [03:00:25.117]                       invokeRestart <- base::invokeRestart
  [03:00:25.117]                       muffled <- FALSE
  [03:00:25.117]                       if (inherits(cond, "message")) {
  [03:00:25.117]                         invokeRestart("muffleMessage")
  [03:00:25.117]                         muffled <- TRUE
  [03:00:25.117]                       }
  [03:00:25.117]                       else if (inherits(cond, "warning")) {
  [03:00:25.117]                         invokeRestart("muffleWarning")
  [03:00:25.117]                         muffled <- TRUE
  [03:00:25.117]                       }
  [03:00:25.117]                       else if (inherits(cond, "condition")) {
  [03:00:25.117]                         computeRestarts <- base::computeRestarts
  [03:00:25.117]                         grepl <- base::grepl
  [03:00:25.117]                         is.null <- base::is.null
  [03:00:25.117]                         restarts <- computeRestarts(cond)
  [03:00:25.117]                         for (restart in restarts) {
  [03:00:25.117]                           name <- restart$name
  [03:00:25.117]                           if (is.null(name)) 
  [03:00:25.117]                             next
  [03:00:25.117]                           if (!grepl("^muffle", name)) 
  [03:00:25.117]                             next
  [03:00:25.117]                           invokeRestart(restart)
  [03:00:25.117]                           muffled <- TRUE
  [03:00:25.117]                           break
  [03:00:25.117]                         }
  [03:00:25.117]                       }
  [03:00:25.117]                       invisible(muffled)
  [03:00:25.117]                     }
  [03:00:25.117]                     muffleCondition(cond)
  [03:00:25.117]                   }
  [03:00:25.117]                 }
  [03:00:25.117]             }
  [03:00:25.117]         }))
  [03:00:25.117]     }, error = function(ex) {
  [03:00:25.117]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.117]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.117]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.117]     }, finally = {
  [03:00:25.117]         {
  [03:00:25.117]             NULL
  [03:00:25.117]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.117]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.117]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.117]                 label = NULL, ...) 
  [03:00:25.117]             {
  [03:00:25.117]                 if (substitute) 
  [03:00:25.117]                   expr <- substitute(expr)
  [03:00:25.117]                 local <- as.logical(local)
  [03:00:25.117]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.117]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.117]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.117]                   label = label, ...)
  [03:00:25.117]                 if (!future$lazy) 
  [03:00:25.117]                   future <- run(future)
  [03:00:25.117]                 invisible(future)
  [03:00:25.117]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.117]         }
  [03:00:25.117]         base::options(...future.oldOptions)
  [03:00:25.117]     })
  [03:00:25.117]     Sys.time
  [03:00:25.117]     if (base::is.na(NA)) {
  [03:00:25.117]     }
  [03:00:25.117]     else {
  [03:00:25.117]         base::sink(type = "output", split = FALSE)
  [03:00:25.117]         if (NA) {
  [03:00:25.117]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.117]         }
  [03:00:25.117]         else {
  [03:00:25.117]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.117]         }
  [03:00:25.117]         base::close(...future.stdout)
  [03:00:25.117]         ...future.stdout <- NULL
  [03:00:25.117]     }
  [03:00:25.117]     ...future.result$conditions <- ...future.conditions
  [03:00:25.117]     ...future.result
  [03:00:25.117] }
  [03:00:25.125] plan(): Setting new future strategy stack:
  [03:00:25.125] List of future strategies:
  [03:00:25.125] 1. sequential:
  [03:00:25.125]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.125]    - tweaked: FALSE
  [03:00:25.125]    - call: NULL
  [03:00:25.127] plan(): nbrOfWorkers() = 1
  [03:00:25.131] Packages needed by the future expression (n = 0): <none>
  [03:00:25.132] Packages needed by future strategies (n = 0): <none>
  [03:00:25.140] {
  [03:00:25.140]     {
  [03:00:25.140]         ...future.startTime <- base::Sys.time()
  [03:00:25.140]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.140]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.140]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.140]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.140]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.140]         {
  [03:00:25.140]             {
  [03:00:25.140]                 base::local({
  [03:00:25.140]                   has_future <- base::requireNamespace("future", 
  [03:00:25.140]                     quietly = TRUE)
  [03:00:25.140]                   version <- if (has_future) 
  [03:00:25.140]                     utils::packageVersion("future")
  [03:00:25.140]                   else NULL
  [03:00:25.140]                   if (!has_future || version < "1.8.0") {
  [03:00:25.140]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.140]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.140]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.140]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.140]                         "release", "version")], collapse = " "), 
  [03:00:25.140]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.140]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.140]                       info)
  [03:00:25.140]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.140]                     if (!has_future) {
  [03:00:25.140]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.140]                         info)
  [03:00:25.140]                     }
  [03:00:25.140]                     else {
  [03:00:25.140]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.140]                         info, version)
  [03:00:25.140]                     }
  [03:00:25.140]                     base::stop(msg)
  [03:00:25.140]                   }
  [03:00:25.140]                 })
  [03:00:25.140]             }
  [03:00:25.140]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.140]         }
  [03:00:25.140]     }
  [03:00:25.140]     if (base::is.na(NA)) {
  [03:00:25.140]     }
  [03:00:25.140]     else {
  [03:00:25.140]         if (NA) {
  [03:00:25.140]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.140]                 open = "w")
  [03:00:25.140]         }
  [03:00:25.140]         else {
  [03:00:25.140]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.140]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.140]         }
  [03:00:25.140]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.140]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.140]             base::sink(type = "output", split = FALSE)
  [03:00:25.140]             base::close(...future.stdout)
  [03:00:25.140]         }, add = TRUE)
  [03:00:25.140]     }
  [03:00:25.140]     ...future.frame <- base::sys.nframe()
  [03:00:25.140]     ...future.conditions <- base::list()
  [03:00:25.140]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.140]     ...future.result <- base::tryCatch({
  [03:00:25.140]         base::withCallingHandlers({
  [03:00:25.140]             ...future.value <- base::withVisible(base::local({
  [03:00:25.140]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.140]             }))
  [03:00:25.140]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.140]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.140]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.140]                 version = "1.8")
  [03:00:25.140]         }, condition = base::local({
  [03:00:25.140]             c <- base::c
  [03:00:25.140]             inherits <- base::inherits
  [03:00:25.140]             invokeRestart <- base::invokeRestart
  [03:00:25.140]             length <- base::length
  [03:00:25.140]             list <- base::list
  [03:00:25.140]             seq.int <- base::seq.int
  [03:00:25.140]             signalCondition <- base::signalCondition
  [03:00:25.140]             sys.calls <- base::sys.calls
  [03:00:25.140]             Sys.time <- base::Sys.time
  [03:00:25.140]             `[[` <- base::`[[`
  [03:00:25.140]             `+` <- base::`+`
  [03:00:25.140]             `<<-` <- base::`<<-`
  [03:00:25.140]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.140]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.140]                   3L)]
  [03:00:25.140]             }
  [03:00:25.140]             function(cond) {
  [03:00:25.140]                 if (inherits(cond, "error")) {
  [03:00:25.140]                   sessionInformation <- function() {
  [03:00:25.140]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.140]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.140]                       search = base::search(), system = base::Sys.info())
  [03:00:25.140]                   }
  [03:00:25.140]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.140]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.140]                     cond$call), session = sessionInformation(), 
  [03:00:25.140]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.140]                   signalCondition(cond)
  [03:00:25.140]                 }
  [03:00:25.140]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.140]                 ))) {
  [03:00:25.140]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.140]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.140]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.140]                   if (!signal) {
  [03:00:25.140]                     muffleCondition <- function (cond) 
  [03:00:25.140]                     {
  [03:00:25.140]                       inherits <- base::inherits
  [03:00:25.140]                       invokeRestart <- base::invokeRestart
  [03:00:25.140]                       muffled <- FALSE
  [03:00:25.140]                       if (inherits(cond, "message")) {
  [03:00:25.140]                         invokeRestart("muffleMessage")
  [03:00:25.140]                         muffled <- TRUE
  [03:00:25.140]                       }
  [03:00:25.140]                       else if (inherits(cond, "warning")) {
  [03:00:25.140]                         invokeRestart("muffleWarning")
  [03:00:25.140]                         muffled <- TRUE
  [03:00:25.140]                       }
  [03:00:25.140]                       else if (inherits(cond, "condition")) {
  [03:00:25.140]                         computeRestarts <- base::computeRestarts
  [03:00:25.140]                         grepl <- base::grepl
  [03:00:25.140]                         is.null <- base::is.null
  [03:00:25.140]                         restarts <- computeRestarts(cond)
  [03:00:25.140]                         for (restart in restarts) {
  [03:00:25.140]                           name <- restart$name
  [03:00:25.140]                           if (is.null(name)) 
  [03:00:25.140]                             next
  [03:00:25.140]                           if (!grepl("^muffle", name)) 
  [03:00:25.140]                             next
  [03:00:25.140]                           invokeRestart(restart)
  [03:00:25.140]                           muffled <- TRUE
  [03:00:25.140]                           break
  [03:00:25.140]                         }
  [03:00:25.140]                       }
  [03:00:25.140]                       invisible(muffled)
  [03:00:25.140]                     }
  [03:00:25.140]                     muffleCondition(cond)
  [03:00:25.140]                   }
  [03:00:25.140]                 }
  [03:00:25.140]             }
  [03:00:25.140]         }))
  [03:00:25.140]     }, error = function(ex) {
  [03:00:25.140]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.140]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.140]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.140]     }, finally = {
  [03:00:25.140]         {
  [03:00:25.140]             NULL
  [03:00:25.140]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.140]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.140]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.140]                 label = NULL, ...) 
  [03:00:25.140]             {
  [03:00:25.140]                 if (substitute) 
  [03:00:25.140]                   expr <- substitute(expr)
  [03:00:25.140]                 local <- as.logical(local)
  [03:00:25.140]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.140]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.140]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.140]                   label = label, ...)
  [03:00:25.140]                 if (!future$lazy) 
  [03:00:25.140]                   future <- run(future)
  [03:00:25.140]                 invisible(future)
  [03:00:25.140]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.140]         }
  [03:00:25.140]         base::options(...future.oldOptions)
  [03:00:25.140]     })
  [03:00:25.140]     Sys.time
  [03:00:25.140]     if (base::is.na(NA)) {
  [03:00:25.140]     }
  [03:00:25.140]     else {
  [03:00:25.140]         base::sink(type = "output", split = FALSE)
  [03:00:25.140]         if (NA) {
  [03:00:25.140]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.140]         }
  [03:00:25.140]         else {
  [03:00:25.140]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.140]         }
  [03:00:25.140]         base::close(...future.stdout)
  [03:00:25.140]         ...future.stdout <- NULL
  [03:00:25.140]     }
  [03:00:25.140]     ...future.result$conditions <- ...future.conditions
  [03:00:25.140]     ...future.result
  [03:00:25.140] }
  [03:00:25.147] plan(): Setting new future strategy stack:
  [03:00:25.148] List of future strategies:
  [03:00:25.148] 1. sequential:
  [03:00:25.148]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.148]    - tweaked: FALSE
  [03:00:25.148]    - call: NULL
  [03:00:25.150] plan(): nbrOfWorkers() = 1
  [03:00:25.154] Packages needed by the future expression (n = 0): <none>
  [03:00:25.155] Packages needed by future strategies (n = 0): <none>
  [03:00:25.163] {
  [03:00:25.163]     {
  [03:00:25.163]         ...future.startTime <- base::Sys.time()
  [03:00:25.163]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.163]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.163]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.163]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.163]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.163]         {
  [03:00:25.163]             {
  [03:00:25.163]                 base::local({
  [03:00:25.163]                   has_future <- base::requireNamespace("future", 
  [03:00:25.163]                     quietly = TRUE)
  [03:00:25.163]                   version <- if (has_future) 
  [03:00:25.163]                     utils::packageVersion("future")
  [03:00:25.163]                   else NULL
  [03:00:25.163]                   if (!has_future || version < "1.8.0") {
  [03:00:25.163]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.163]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.163]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.163]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.163]                         "release", "version")], collapse = " "), 
  [03:00:25.163]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.163]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.163]                       info)
  [03:00:25.163]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.163]                     if (!has_future) {
  [03:00:25.163]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.163]                         info)
  [03:00:25.163]                     }
  [03:00:25.163]                     else {
  [03:00:25.163]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.163]                         info, version)
  [03:00:25.163]                     }
  [03:00:25.163]                     base::stop(msg)
  [03:00:25.163]                   }
  [03:00:25.163]                 })
  [03:00:25.163]             }
  [03:00:25.163]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.163]         }
  [03:00:25.163]     }
  [03:00:25.163]     if (base::is.na(NA)) {
  [03:00:25.163]     }
  [03:00:25.163]     else {
  [03:00:25.163]         if (NA) {
  [03:00:25.163]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.163]                 open = "w")
  [03:00:25.163]         }
  [03:00:25.163]         else {
  [03:00:25.163]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.163]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.163]         }
  [03:00:25.163]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.163]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.163]             base::sink(type = "output", split = FALSE)
  [03:00:25.163]             base::close(...future.stdout)
  [03:00:25.163]         }, add = TRUE)
  [03:00:25.163]     }
  [03:00:25.163]     ...future.frame <- base::sys.nframe()
  [03:00:25.163]     ...future.conditions <- base::list()
  [03:00:25.163]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.163]     ...future.result <- base::tryCatch({
  [03:00:25.163]         base::withCallingHandlers({
  [03:00:25.163]             ...future.value <- base::withVisible(base::local({
  [03:00:25.163]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.163]             }))
  [03:00:25.163]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.163]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.163]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.163]                 version = "1.8")
  [03:00:25.163]         }, condition = base::local({
  [03:00:25.163]             c <- base::c
  [03:00:25.163]             inherits <- base::inherits
  [03:00:25.163]             invokeRestart <- base::invokeRestart
  [03:00:25.163]             length <- base::length
  [03:00:25.163]             list <- base::list
  [03:00:25.163]             seq.int <- base::seq.int
  [03:00:25.163]             signalCondition <- base::signalCondition
  [03:00:25.163]             sys.calls <- base::sys.calls
  [03:00:25.163]             Sys.time <- base::Sys.time
  [03:00:25.163]             `[[` <- base::`[[`
  [03:00:25.163]             `+` <- base::`+`
  [03:00:25.163]             `<<-` <- base::`<<-`
  [03:00:25.163]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.163]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.163]                   3L)]
  [03:00:25.163]             }
  [03:00:25.163]             function(cond) {
  [03:00:25.163]                 if (inherits(cond, "error")) {
  [03:00:25.163]                   sessionInformation <- function() {
  [03:00:25.163]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.163]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.163]                       search = base::search(), system = base::Sys.info())
  [03:00:25.163]                   }
  [03:00:25.163]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.163]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.163]                     cond$call), session = sessionInformation(), 
  [03:00:25.163]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.163]                   signalCondition(cond)
  [03:00:25.163]                 }
  [03:00:25.163]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.163]                 ))) {
  [03:00:25.163]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.163]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.163]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.163]                   if (!signal) {
  [03:00:25.163]                     muffleCondition <- function (cond) 
  [03:00:25.163]                     {
  [03:00:25.163]                       inherits <- base::inherits
  [03:00:25.163]                       invokeRestart <- base::invokeRestart
  [03:00:25.163]                       muffled <- FALSE
  [03:00:25.163]                       if (inherits(cond, "message")) {
  [03:00:25.163]                         invokeRestart("muffleMessage")
  [03:00:25.163]                         muffled <- TRUE
  [03:00:25.163]                       }
  [03:00:25.163]                       else if (inherits(cond, "warning")) {
  [03:00:25.163]                         invokeRestart("muffleWarning")
  [03:00:25.163]                         muffled <- TRUE
  [03:00:25.163]                       }
  [03:00:25.163]                       else if (inherits(cond, "condition")) {
  [03:00:25.163]                         computeRestarts <- base::computeRestarts
  [03:00:25.163]                         grepl <- base::grepl
  [03:00:25.163]                         is.null <- base::is.null
  [03:00:25.163]                         restarts <- computeRestarts(cond)
  [03:00:25.163]                         for (restart in restarts) {
  [03:00:25.163]                           name <- restart$name
  [03:00:25.163]                           if (is.null(name)) 
  [03:00:25.163]                             next
  [03:00:25.163]                           if (!grepl("^muffle", name)) 
  [03:00:25.163]                             next
  [03:00:25.163]                           invokeRestart(restart)
  [03:00:25.163]                           muffled <- TRUE
  [03:00:25.163]                           break
  [03:00:25.163]                         }
  [03:00:25.163]                       }
  [03:00:25.163]                       invisible(muffled)
  [03:00:25.163]                     }
  [03:00:25.163]                     muffleCondition(cond)
  [03:00:25.163]                   }
  [03:00:25.163]                 }
  [03:00:25.163]             }
  [03:00:25.163]         }))
  [03:00:25.163]     }, error = function(ex) {
  [03:00:25.163]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.163]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.163]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.163]     }, finally = {
  [03:00:25.163]         {
  [03:00:25.163]             NULL
  [03:00:25.163]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.163]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.163]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.163]                 label = NULL, ...) 
  [03:00:25.163]             {
  [03:00:25.163]                 if (substitute) 
  [03:00:25.163]                   expr <- substitute(expr)
  [03:00:25.163]                 local <- as.logical(local)
  [03:00:25.163]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.163]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.163]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.163]                   label = label, ...)
  [03:00:25.163]                 if (!future$lazy) 
  [03:00:25.163]                   future <- run(future)
  [03:00:25.163]                 invisible(future)
  [03:00:25.163]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.163]         }
  [03:00:25.163]         base::options(...future.oldOptions)
  [03:00:25.163]     })
  [03:00:25.163]     Sys.time
  [03:00:25.163]     if (base::is.na(NA)) {
  [03:00:25.163]     }
  [03:00:25.163]     else {
  [03:00:25.163]         base::sink(type = "output", split = FALSE)
  [03:00:25.163]         if (NA) {
  [03:00:25.163]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.163]         }
  [03:00:25.163]         else {
  [03:00:25.163]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.163]         }
  [03:00:25.163]         base::close(...future.stdout)
  [03:00:25.163]         ...future.stdout <- NULL
  [03:00:25.163]     }
  [03:00:25.163]     ...future.result$conditions <- ...future.conditions
  [03:00:25.163]     ...future.result
  [03:00:25.163] }
  [03:00:25.171] plan(): Setting new future strategy stack:
  [03:00:25.172] List of future strategies:
  [03:00:25.172] 1. sequential:
  [03:00:25.172]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.172]    - tweaked: FALSE
  [03:00:25.172]    - call: NULL
  [03:00:25.174] plan(): nbrOfWorkers() = 1
  [03:00:25.178] Packages needed by the future expression (n = 0): <none>
  [03:00:25.179] Packages needed by future strategies (n = 0): <none>
  [03:00:25.197] {
  [03:00:25.197]     {
  [03:00:25.197]         ...future.startTime <- base::Sys.time()
  [03:00:25.197]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.197]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.197]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.197]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.197]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.197]         {
  [03:00:25.197]             {
  [03:00:25.197]                 base::local({
  [03:00:25.197]                   has_future <- base::requireNamespace("future", 
  [03:00:25.197]                     quietly = TRUE)
  [03:00:25.197]                   version <- if (has_future) 
  [03:00:25.197]                     utils::packageVersion("future")
  [03:00:25.197]                   else NULL
  [03:00:25.197]                   if (!has_future || version < "1.8.0") {
  [03:00:25.197]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.197]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.197]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.197]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.197]                         "release", "version")], collapse = " "), 
  [03:00:25.197]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.197]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.197]                       info)
  [03:00:25.197]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.197]                     if (!has_future) {
  [03:00:25.197]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.197]                         info)
  [03:00:25.197]                     }
  [03:00:25.197]                     else {
  [03:00:25.197]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.197]                         info, version)
  [03:00:25.197]                     }
  [03:00:25.197]                     base::stop(msg)
  [03:00:25.197]                   }
  [03:00:25.197]                 })
  [03:00:25.197]             }
  [03:00:25.197]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.197]         }
  [03:00:25.197]     }
  [03:00:25.197]     if (base::is.na(NA)) {
  [03:00:25.197]     }
  [03:00:25.197]     else {
  [03:00:25.197]         if (NA) {
  [03:00:25.197]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.197]                 open = "w")
  [03:00:25.197]         }
  [03:00:25.197]         else {
  [03:00:25.197]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.197]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.197]         }
  [03:00:25.197]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.197]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.197]             base::sink(type = "output", split = FALSE)
  [03:00:25.197]             base::close(...future.stdout)
  [03:00:25.197]         }, add = TRUE)
  [03:00:25.197]     }
  [03:00:25.197]     ...future.frame <- base::sys.nframe()
  [03:00:25.197]     ...future.conditions <- base::list()
  [03:00:25.197]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.197]     ...future.result <- base::tryCatch({
  [03:00:25.197]         base::withCallingHandlers({
  [03:00:25.197]             ...future.value <- base::withVisible(base::local({
  [03:00:25.197]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.197]             }))
  [03:00:25.197]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.197]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.197]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.197]                 version = "1.8")
  [03:00:25.197]         }, condition = base::local({
  [03:00:25.197]             c <- base::c
  [03:00:25.197]             inherits <- base::inherits
  [03:00:25.197]             invokeRestart <- base::invokeRestart
  [03:00:25.197]             length <- base::length
  [03:00:25.197]             list <- base::list
  [03:00:25.197]             seq.int <- base::seq.int
  [03:00:25.197]             signalCondition <- base::signalCondition
  [03:00:25.197]             sys.calls <- base::sys.calls
  [03:00:25.197]             Sys.time <- base::Sys.time
  [03:00:25.197]             `[[` <- base::`[[`
  [03:00:25.197]             `+` <- base::`+`
  [03:00:25.197]             `<<-` <- base::`<<-`
  [03:00:25.197]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.197]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.197]                   3L)]
  [03:00:25.197]             }
  [03:00:25.197]             function(cond) {
  [03:00:25.197]                 if (inherits(cond, "error")) {
  [03:00:25.197]                   sessionInformation <- function() {
  [03:00:25.197]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.197]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.197]                       search = base::search(), system = base::Sys.info())
  [03:00:25.197]                   }
  [03:00:25.197]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.197]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.197]                     cond$call), session = sessionInformation(), 
  [03:00:25.197]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.197]                   signalCondition(cond)
  [03:00:25.197]                 }
  [03:00:25.197]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.197]                 ))) {
  [03:00:25.197]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.197]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.197]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.197]                   if (!signal) {
  [03:00:25.197]                     muffleCondition <- function (cond) 
  [03:00:25.197]                     {
  [03:00:25.197]                       inherits <- base::inherits
  [03:00:25.197]                       invokeRestart <- base::invokeRestart
  [03:00:25.197]                       muffled <- FALSE
  [03:00:25.197]                       if (inherits(cond, "message")) {
  [03:00:25.197]                         invokeRestart("muffleMessage")
  [03:00:25.197]                         muffled <- TRUE
  [03:00:25.197]                       }
  [03:00:25.197]                       else if (inherits(cond, "warning")) {
  [03:00:25.197]                         invokeRestart("muffleWarning")
  [03:00:25.197]                         muffled <- TRUE
  [03:00:25.197]                       }
  [03:00:25.197]                       else if (inherits(cond, "condition")) {
  [03:00:25.197]                         computeRestarts <- base::computeRestarts
  [03:00:25.197]                         grepl <- base::grepl
  [03:00:25.197]                         is.null <- base::is.null
  [03:00:25.197]                         restarts <- computeRestarts(cond)
  [03:00:25.197]                         for (restart in restarts) {
  [03:00:25.197]                           name <- restart$name
  [03:00:25.197]                           if (is.null(name)) 
  [03:00:25.197]                             next
  [03:00:25.197]                           if (!grepl("^muffle", name)) 
  [03:00:25.197]                             next
  [03:00:25.197]                           invokeRestart(restart)
  [03:00:25.197]                           muffled <- TRUE
  [03:00:25.197]                           break
  [03:00:25.197]                         }
  [03:00:25.197]                       }
  [03:00:25.197]                       invisible(muffled)
  [03:00:25.197]                     }
  [03:00:25.197]                     muffleCondition(cond)
  [03:00:25.197]                   }
  [03:00:25.197]                 }
  [03:00:25.197]             }
  [03:00:25.197]         }))
  [03:00:25.197]     }, error = function(ex) {
  [03:00:25.197]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.197]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.197]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.197]     }, finally = {
  [03:00:25.197]         {
  [03:00:25.197]             NULL
  [03:00:25.197]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.197]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.197]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.197]                 label = NULL, ...) 
  [03:00:25.197]             {
  [03:00:25.197]                 if (substitute) 
  [03:00:25.197]                   expr <- substitute(expr)
  [03:00:25.197]                 local <- as.logical(local)
  [03:00:25.197]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.197]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.197]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.197]                   label = label, ...)
  [03:00:25.197]                 if (!future$lazy) 
  [03:00:25.197]                   future <- run(future)
  [03:00:25.197]                 invisible(future)
  [03:00:25.197]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.197]         }
  [03:00:25.197]         base::options(...future.oldOptions)
  [03:00:25.197]     })
  [03:00:25.197]     Sys.time
  [03:00:25.197]     if (base::is.na(NA)) {
  [03:00:25.197]     }
  [03:00:25.197]     else {
  [03:00:25.197]         base::sink(type = "output", split = FALSE)
  [03:00:25.197]         if (NA) {
  [03:00:25.197]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.197]         }
  [03:00:25.197]         else {
  [03:00:25.197]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.197]         }
  [03:00:25.197]         base::close(...future.stdout)
  [03:00:25.197]         ...future.stdout <- NULL
  [03:00:25.197]     }
  [03:00:25.197]     ...future.result$conditions <- ...future.conditions
  [03:00:25.197]     ...future.result
  [03:00:25.197] }
  [03:00:25.206] plan(): Setting new future strategy stack:
  [03:00:25.208] List of future strategies:
  [03:00:25.208] 1. sequential:
  [03:00:25.208]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.208]    - tweaked: FALSE
  [03:00:25.208]    - call: NULL
  [03:00:25.210] plan(): nbrOfWorkers() = 1
  [03:00:25.215] Packages needed by the future expression (n = 0): <none>
  [03:00:25.217] Packages needed by future strategies (n = 0): <none>
  [03:00:25.226] {
  [03:00:25.226]     {
  [03:00:25.226]         ...future.startTime <- base::Sys.time()
  [03:00:25.226]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.226]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.226]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.226]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.226]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.226]         {
  [03:00:25.226]             {
  [03:00:25.226]                 base::local({
  [03:00:25.226]                   has_future <- base::requireNamespace("future", 
  [03:00:25.226]                     quietly = TRUE)
  [03:00:25.226]                   version <- if (has_future) 
  [03:00:25.226]                     utils::packageVersion("future")
  [03:00:25.226]                   else NULL
  [03:00:25.226]                   if (!has_future || version < "1.8.0") {
  [03:00:25.226]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.226]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.226]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.226]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.226]                         "release", "version")], collapse = " "), 
  [03:00:25.226]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.226]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.226]                       info)
  [03:00:25.226]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.226]                     if (!has_future) {
  [03:00:25.226]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.226]                         info)
  [03:00:25.226]                     }
  [03:00:25.226]                     else {
  [03:00:25.226]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.226]                         info, version)
  [03:00:25.226]                     }
  [03:00:25.226]                     base::stop(msg)
  [03:00:25.226]                   }
  [03:00:25.226]                 })
  [03:00:25.226]             }
  [03:00:25.226]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.226]         }
  [03:00:25.226]     }
  [03:00:25.226]     if (base::is.na(NA)) {
  [03:00:25.226]     }
  [03:00:25.226]     else {
  [03:00:25.226]         if (NA) {
  [03:00:25.226]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.226]                 open = "w")
  [03:00:25.226]         }
  [03:00:25.226]         else {
  [03:00:25.226]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.226]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.226]         }
  [03:00:25.226]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.226]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.226]             base::sink(type = "output", split = FALSE)
  [03:00:25.226]             base::close(...future.stdout)
  [03:00:25.226]         }, add = TRUE)
  [03:00:25.226]     }
  [03:00:25.226]     ...future.frame <- base::sys.nframe()
  [03:00:25.226]     ...future.conditions <- base::list()
  [03:00:25.226]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.226]     ...future.result <- base::tryCatch({
  [03:00:25.226]         base::withCallingHandlers({
  [03:00:25.226]             ...future.value <- base::withVisible(base::local({
  [03:00:25.226]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.226]             }))
  [03:00:25.226]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.226]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.226]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.226]                 version = "1.8")
  [03:00:25.226]         }, condition = base::local({
  [03:00:25.226]             c <- base::c
  [03:00:25.226]             inherits <- base::inherits
  [03:00:25.226]             invokeRestart <- base::invokeRestart
  [03:00:25.226]             length <- base::length
  [03:00:25.226]             list <- base::list
  [03:00:25.226]             seq.int <- base::seq.int
  [03:00:25.226]             signalCondition <- base::signalCondition
  [03:00:25.226]             sys.calls <- base::sys.calls
  [03:00:25.226]             Sys.time <- base::Sys.time
  [03:00:25.226]             `[[` <- base::`[[`
  [03:00:25.226]             `+` <- base::`+`
  [03:00:25.226]             `<<-` <- base::`<<-`
  [03:00:25.226]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.226]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.226]                   3L)]
  [03:00:25.226]             }
  [03:00:25.226]             function(cond) {
  [03:00:25.226]                 if (inherits(cond, "error")) {
  [03:00:25.226]                   sessionInformation <- function() {
  [03:00:25.226]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.226]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.226]                       search = base::search(), system = base::Sys.info())
  [03:00:25.226]                   }
  [03:00:25.226]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.226]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.226]                     cond$call), session = sessionInformation(), 
  [03:00:25.226]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.226]                   signalCondition(cond)
  [03:00:25.226]                 }
  [03:00:25.226]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.226]                 ))) {
  [03:00:25.226]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.226]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.226]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.226]                   if (!signal) {
  [03:00:25.226]                     muffleCondition <- function (cond) 
  [03:00:25.226]                     {
  [03:00:25.226]                       inherits <- base::inherits
  [03:00:25.226]                       invokeRestart <- base::invokeRestart
  [03:00:25.226]                       muffled <- FALSE
  [03:00:25.226]                       if (inherits(cond, "message")) {
  [03:00:25.226]                         invokeRestart("muffleMessage")
  [03:00:25.226]                         muffled <- TRUE
  [03:00:25.226]                       }
  [03:00:25.226]                       else if (inherits(cond, "warning")) {
  [03:00:25.226]                         invokeRestart("muffleWarning")
  [03:00:25.226]                         muffled <- TRUE
  [03:00:25.226]                       }
  [03:00:25.226]                       else if (inherits(cond, "condition")) {
  [03:00:25.226]                         computeRestarts <- base::computeRestarts
  [03:00:25.226]                         grepl <- base::grepl
  [03:00:25.226]                         is.null <- base::is.null
  [03:00:25.226]                         restarts <- computeRestarts(cond)
  [03:00:25.226]                         for (restart in restarts) {
  [03:00:25.226]                           name <- restart$name
  [03:00:25.226]                           if (is.null(name)) 
  [03:00:25.226]                             next
  [03:00:25.226]                           if (!grepl("^muffle", name)) 
  [03:00:25.226]                             next
  [03:00:25.226]                           invokeRestart(restart)
  [03:00:25.226]                           muffled <- TRUE
  [03:00:25.226]                           break
  [03:00:25.226]                         }
  [03:00:25.226]                       }
  [03:00:25.226]                       invisible(muffled)
  [03:00:25.226]                     }
  [03:00:25.226]                     muffleCondition(cond)
  [03:00:25.226]                   }
  [03:00:25.226]                 }
  [03:00:25.226]             }
  [03:00:25.226]         }))
  [03:00:25.226]     }, error = function(ex) {
  [03:00:25.226]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.226]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.226]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.226]     }, finally = {
  [03:00:25.226]         {
  [03:00:25.226]             NULL
  [03:00:25.226]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.226]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.226]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.226]                 label = NULL, ...) 
  [03:00:25.226]             {
  [03:00:25.226]                 if (substitute) 
  [03:00:25.226]                   expr <- substitute(expr)
  [03:00:25.226]                 local <- as.logical(local)
  [03:00:25.226]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.226]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.226]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.226]                   label = label, ...)
  [03:00:25.226]                 if (!future$lazy) 
  [03:00:25.226]                   future <- run(future)
  [03:00:25.226]                 invisible(future)
  [03:00:25.226]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.226]         }
  [03:00:25.226]         base::options(...future.oldOptions)
  [03:00:25.226]     })
  [03:00:25.226]     Sys.time
  [03:00:25.226]     if (base::is.na(NA)) {
  [03:00:25.226]     }
  [03:00:25.226]     else {
  [03:00:25.226]         base::sink(type = "output", split = FALSE)
  [03:00:25.226]         if (NA) {
  [03:00:25.226]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.226]         }
  [03:00:25.226]         else {
  [03:00:25.226]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.226]         }
  [03:00:25.226]         base::close(...future.stdout)
  [03:00:25.226]         ...future.stdout <- NULL
  [03:00:25.226]     }
  [03:00:25.226]     ...future.result$conditions <- ...future.conditions
  [03:00:25.226]     ...future.result
  [03:00:25.226] }
  [03:00:25.234] plan(): Setting new future strategy stack:
  [03:00:25.235] List of future strategies:
  [03:00:25.235] 1. sequential:
  [03:00:25.235]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.235]    - tweaked: FALSE
  [03:00:25.235]    - call: NULL
  [03:00:25.238] plan(): nbrOfWorkers() = 1
  [03:00:25.242] Packages needed by the future expression (n = 0): <none>
  [03:00:25.244] Packages needed by future strategies (n = 0): <none>
  [03:00:25.254] {
  [03:00:25.254]     {
  [03:00:25.254]         ...future.startTime <- base::Sys.time()
  [03:00:25.254]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.254]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.254]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.254]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.254]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.254]         {
  [03:00:25.254]             {
  [03:00:25.254]                 base::local({
  [03:00:25.254]                   has_future <- base::requireNamespace("future", 
  [03:00:25.254]                     quietly = TRUE)
  [03:00:25.254]                   version <- if (has_future) 
  [03:00:25.254]                     utils::packageVersion("future")
  [03:00:25.254]                   else NULL
  [03:00:25.254]                   if (!has_future || version < "1.8.0") {
  [03:00:25.254]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.254]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.254]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.254]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.254]                         "release", "version")], collapse = " "), 
  [03:00:25.254]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.254]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.254]                       info)
  [03:00:25.254]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.254]                     if (!has_future) {
  [03:00:25.254]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.254]                         info)
  [03:00:25.254]                     }
  [03:00:25.254]                     else {
  [03:00:25.254]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.254]                         info, version)
  [03:00:25.254]                     }
  [03:00:25.254]                     base::stop(msg)
  [03:00:25.254]                   }
  [03:00:25.254]                 })
  [03:00:25.254]             }
  [03:00:25.254]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.254]         }
  [03:00:25.254]     }
  [03:00:25.254]     if (base::is.na(NA)) {
  [03:00:25.254]     }
  [03:00:25.254]     else {
  [03:00:25.254]         if (NA) {
  [03:00:25.254]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.254]                 open = "w")
  [03:00:25.254]         }
  [03:00:25.254]         else {
  [03:00:25.254]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.254]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.254]         }
  [03:00:25.254]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.254]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.254]             base::sink(type = "output", split = FALSE)
  [03:00:25.254]             base::close(...future.stdout)
  [03:00:25.254]         }, add = TRUE)
  [03:00:25.254]     }
  [03:00:25.254]     ...future.frame <- base::sys.nframe()
  [03:00:25.254]     ...future.conditions <- base::list()
  [03:00:25.254]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.254]     ...future.result <- base::tryCatch({
  [03:00:25.254]         base::withCallingHandlers({
  [03:00:25.254]             ...future.value <- base::withVisible(base::local({
  [03:00:25.254]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.254]             }))
  [03:00:25.254]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.254]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.254]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.254]                 version = "1.8")
  [03:00:25.254]         }, condition = base::local({
  [03:00:25.254]             c <- base::c
  [03:00:25.254]             inherits <- base::inherits
  [03:00:25.254]             invokeRestart <- base::invokeRestart
  [03:00:25.254]             length <- base::length
  [03:00:25.254]             list <- base::list
  [03:00:25.254]             seq.int <- base::seq.int
  [03:00:25.254]             signalCondition <- base::signalCondition
  [03:00:25.254]             sys.calls <- base::sys.calls
  [03:00:25.254]             Sys.time <- base::Sys.time
  [03:00:25.254]             `[[` <- base::`[[`
  [03:00:25.254]             `+` <- base::`+`
  [03:00:25.254]             `<<-` <- base::`<<-`
  [03:00:25.254]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.254]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.254]                   3L)]
  [03:00:25.254]             }
  [03:00:25.254]             function(cond) {
  [03:00:25.254]                 if (inherits(cond, "error")) {
  [03:00:25.254]                   sessionInformation <- function() {
  [03:00:25.254]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.254]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.254]                       search = base::search(), system = base::Sys.info())
  [03:00:25.254]                   }
  [03:00:25.254]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.254]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.254]                     cond$call), session = sessionInformation(), 
  [03:00:25.254]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.254]                   signalCondition(cond)
  [03:00:25.254]                 }
  [03:00:25.254]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.254]                 ))) {
  [03:00:25.254]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.254]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.254]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.254]                   if (!signal) {
  [03:00:25.254]                     muffleCondition <- function (cond) 
  [03:00:25.254]                     {
  [03:00:25.254]                       inherits <- base::inherits
  [03:00:25.254]                       invokeRestart <- base::invokeRestart
  [03:00:25.254]                       muffled <- FALSE
  [03:00:25.254]                       if (inherits(cond, "message")) {
  [03:00:25.254]                         invokeRestart("muffleMessage")
  [03:00:25.254]                         muffled <- TRUE
  [03:00:25.254]                       }
  [03:00:25.254]                       else if (inherits(cond, "warning")) {
  [03:00:25.254]                         invokeRestart("muffleWarning")
  [03:00:25.254]                         muffled <- TRUE
  [03:00:25.254]                       }
  [03:00:25.254]                       else if (inherits(cond, "condition")) {
  [03:00:25.254]                         computeRestarts <- base::computeRestarts
  [03:00:25.254]                         grepl <- base::grepl
  [03:00:25.254]                         is.null <- base::is.null
  [03:00:25.254]                         restarts <- computeRestarts(cond)
  [03:00:25.254]                         for (restart in restarts) {
  [03:00:25.254]                           name <- restart$name
  [03:00:25.254]                           if (is.null(name)) 
  [03:00:25.254]                             next
  [03:00:25.254]                           if (!grepl("^muffle", name)) 
  [03:00:25.254]                             next
  [03:00:25.254]                           invokeRestart(restart)
  [03:00:25.254]                           muffled <- TRUE
  [03:00:25.254]                           break
  [03:00:25.254]                         }
  [03:00:25.254]                       }
  [03:00:25.254]                       invisible(muffled)
  [03:00:25.254]                     }
  [03:00:25.254]                     muffleCondition(cond)
  [03:00:25.254]                   }
  [03:00:25.254]                 }
  [03:00:25.254]             }
  [03:00:25.254]         }))
  [03:00:25.254]     }, error = function(ex) {
  [03:00:25.254]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.254]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.254]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.254]     }, finally = {
  [03:00:25.254]         {
  [03:00:25.254]             NULL
  [03:00:25.254]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.254]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.254]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.254]                 label = NULL, ...) 
  [03:00:25.254]             {
  [03:00:25.254]                 if (substitute) 
  [03:00:25.254]                   expr <- substitute(expr)
  [03:00:25.254]                 local <- as.logical(local)
  [03:00:25.254]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.254]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.254]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.254]                   label = label, ...)
  [03:00:25.254]                 if (!future$lazy) 
  [03:00:25.254]                   future <- run(future)
  [03:00:25.254]                 invisible(future)
  [03:00:25.254]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.254]         }
  [03:00:25.254]         base::options(...future.oldOptions)
  [03:00:25.254]     })
  [03:00:25.254]     Sys.time
  [03:00:25.254]     if (base::is.na(NA)) {
  [03:00:25.254]     }
  [03:00:25.254]     else {
  [03:00:25.254]         base::sink(type = "output", split = FALSE)
  [03:00:25.254]         if (NA) {
  [03:00:25.254]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.254]         }
  [03:00:25.254]         else {
  [03:00:25.254]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.254]         }
  [03:00:25.254]         base::close(...future.stdout)
  [03:00:25.254]         ...future.stdout <- NULL
  [03:00:25.254]     }
  [03:00:25.254]     ...future.result$conditions <- ...future.conditions
  [03:00:25.254]     ...future.result
  [03:00:25.254] }
  [03:00:25.263] plan(): Setting new future strategy stack:
  [03:00:25.264] List of future strategies:
  [03:00:25.264] 1. sequential:
  [03:00:25.264]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.264]    - tweaked: FALSE
  [03:00:25.264]    - call: NULL
  [03:00:25.267] plan(): nbrOfWorkers() = 1
  [03:00:25.273] Packages needed by the future expression (n = 0): <none>
  [03:00:25.275] Packages needed by future strategies (n = 0): <none>
  [03:00:25.285] {
  [03:00:25.285]     {
  [03:00:25.285]         ...future.startTime <- base::Sys.time()
  [03:00:25.285]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.285]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.285]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.285]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.285]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.285]         {
  [03:00:25.285]             {
  [03:00:25.285]                 base::local({
  [03:00:25.285]                   has_future <- base::requireNamespace("future", 
  [03:00:25.285]                     quietly = TRUE)
  [03:00:25.285]                   version <- if (has_future) 
  [03:00:25.285]                     utils::packageVersion("future")
  [03:00:25.285]                   else NULL
  [03:00:25.285]                   if (!has_future || version < "1.8.0") {
  [03:00:25.285]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.285]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.285]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.285]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.285]                         "release", "version")], collapse = " "), 
  [03:00:25.285]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.285]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.285]                       info)
  [03:00:25.285]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.285]                     if (!has_future) {
  [03:00:25.285]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.285]                         info)
  [03:00:25.285]                     }
  [03:00:25.285]                     else {
  [03:00:25.285]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.285]                         info, version)
  [03:00:25.285]                     }
  [03:00:25.285]                     base::stop(msg)
  [03:00:25.285]                   }
  [03:00:25.285]                 })
  [03:00:25.285]             }
  [03:00:25.285]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.285]         }
  [03:00:25.285]     }
  [03:00:25.285]     if (base::is.na(NA)) {
  [03:00:25.285]     }
  [03:00:25.285]     else {
  [03:00:25.285]         if (NA) {
  [03:00:25.285]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.285]                 open = "w")
  [03:00:25.285]         }
  [03:00:25.285]         else {
  [03:00:25.285]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.285]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.285]         }
  [03:00:25.285]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.285]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.285]             base::sink(type = "output", split = FALSE)
  [03:00:25.285]             base::close(...future.stdout)
  [03:00:25.285]         }, add = TRUE)
  [03:00:25.285]     }
  [03:00:25.285]     ...future.frame <- base::sys.nframe()
  [03:00:25.285]     ...future.conditions <- base::list()
  [03:00:25.285]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.285]     ...future.result <- base::tryCatch({
  [03:00:25.285]         base::withCallingHandlers({
  [03:00:25.285]             ...future.value <- base::withVisible(base::local({
  [03:00:25.285]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.285]             }))
  [03:00:25.285]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.285]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.285]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.285]                 version = "1.8")
  [03:00:25.285]         }, condition = base::local({
  [03:00:25.285]             c <- base::c
  [03:00:25.285]             inherits <- base::inherits
  [03:00:25.285]             invokeRestart <- base::invokeRestart
  [03:00:25.285]             length <- base::length
  [03:00:25.285]             list <- base::list
  [03:00:25.285]             seq.int <- base::seq.int
  [03:00:25.285]             signalCondition <- base::signalCondition
  [03:00:25.285]             sys.calls <- base::sys.calls
  [03:00:25.285]             Sys.time <- base::Sys.time
  [03:00:25.285]             `[[` <- base::`[[`
  [03:00:25.285]             `+` <- base::`+`
  [03:00:25.285]             `<<-` <- base::`<<-`
  [03:00:25.285]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.285]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.285]                   3L)]
  [03:00:25.285]             }
  [03:00:25.285]             function(cond) {
  [03:00:25.285]                 if (inherits(cond, "error")) {
  [03:00:25.285]                   sessionInformation <- function() {
  [03:00:25.285]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.285]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.285]                       search = base::search(), system = base::Sys.info())
  [03:00:25.285]                   }
  [03:00:25.285]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.285]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.285]                     cond$call), session = sessionInformation(), 
  [03:00:25.285]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.285]                   signalCondition(cond)
  [03:00:25.285]                 }
  [03:00:25.285]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.285]                 ))) {
  [03:00:25.285]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.285]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.285]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.285]                   if (!signal) {
  [03:00:25.285]                     muffleCondition <- function (cond) 
  [03:00:25.285]                     {
  [03:00:25.285]                       inherits <- base::inherits
  [03:00:25.285]                       invokeRestart <- base::invokeRestart
  [03:00:25.285]                       muffled <- FALSE
  [03:00:25.285]                       if (inherits(cond, "message")) {
  [03:00:25.285]                         invokeRestart("muffleMessage")
  [03:00:25.285]                         muffled <- TRUE
  [03:00:25.285]                       }
  [03:00:25.285]                       else if (inherits(cond, "warning")) {
  [03:00:25.285]                         invokeRestart("muffleWarning")
  [03:00:25.285]                         muffled <- TRUE
  [03:00:25.285]                       }
  [03:00:25.285]                       else if (inherits(cond, "condition")) {
  [03:00:25.285]                         computeRestarts <- base::computeRestarts
  [03:00:25.285]                         grepl <- base::grepl
  [03:00:25.285]                         is.null <- base::is.null
  [03:00:25.285]                         restarts <- computeRestarts(cond)
  [03:00:25.285]                         for (restart in restarts) {
  [03:00:25.285]                           name <- restart$name
  [03:00:25.285]                           if (is.null(name)) 
  [03:00:25.285]                             next
  [03:00:25.285]                           if (!grepl("^muffle", name)) 
  [03:00:25.285]                             next
  [03:00:25.285]                           invokeRestart(restart)
  [03:00:25.285]                           muffled <- TRUE
  [03:00:25.285]                           break
  [03:00:25.285]                         }
  [03:00:25.285]                       }
  [03:00:25.285]                       invisible(muffled)
  [03:00:25.285]                     }
  [03:00:25.285]                     muffleCondition(cond)
  [03:00:25.285]                   }
  [03:00:25.285]                 }
  [03:00:25.285]             }
  [03:00:25.285]         }))
  [03:00:25.285]     }, error = function(ex) {
  [03:00:25.285]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.285]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.285]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.285]     }, finally = {
  [03:00:25.285]         {
  [03:00:25.285]             NULL
  [03:00:25.285]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.285]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.285]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.285]                 label = NULL, ...) 
  [03:00:25.285]             {
  [03:00:25.285]                 if (substitute) 
  [03:00:25.285]                   expr <- substitute(expr)
  [03:00:25.285]                 local <- as.logical(local)
  [03:00:25.285]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.285]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.285]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.285]                   label = label, ...)
  [03:00:25.285]                 if (!future$lazy) 
  [03:00:25.285]                   future <- run(future)
  [03:00:25.285]                 invisible(future)
  [03:00:25.285]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.285]         }
  [03:00:25.285]         base::options(...future.oldOptions)
  [03:00:25.285]     })
  [03:00:25.285]     Sys.time
  [03:00:25.285]     if (base::is.na(NA)) {
  [03:00:25.285]     }
  [03:00:25.285]     else {
  [03:00:25.285]         base::sink(type = "output", split = FALSE)
  [03:00:25.285]         if (NA) {
  [03:00:25.285]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.285]         }
  [03:00:25.285]         else {
  [03:00:25.285]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.285]         }
  [03:00:25.285]         base::close(...future.stdout)
  [03:00:25.285]         ...future.stdout <- NULL
  [03:00:25.285]     }
  [03:00:25.285]     ...future.result$conditions <- ...future.conditions
  [03:00:25.285]     ...future.result
  [03:00:25.285] }
  [03:00:25.294] plan(): Setting new future strategy stack:
  [03:00:25.296] List of future strategies:
  [03:00:25.296] 1. sequential:
  [03:00:25.296]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.296]    - tweaked: FALSE
  [03:00:25.296]    - call: NULL
  [03:00:25.299] plan(): nbrOfWorkers() = 1
  [03:00:25.304] Packages needed by the future expression (n = 0): <none>
  [03:00:25.307] Packages needed by future strategies (n = 0): <none>
  [03:00:25.315] {
  [03:00:25.315]     {
  [03:00:25.315]         ...future.startTime <- base::Sys.time()
  [03:00:25.315]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.315]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.315]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.315]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.315]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.315]         {
  [03:00:25.315]             {
  [03:00:25.315]                 base::local({
  [03:00:25.315]                   has_future <- base::requireNamespace("future", 
  [03:00:25.315]                     quietly = TRUE)
  [03:00:25.315]                   version <- if (has_future) 
  [03:00:25.315]                     utils::packageVersion("future")
  [03:00:25.315]                   else NULL
  [03:00:25.315]                   if (!has_future || version < "1.8.0") {
  [03:00:25.315]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.315]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.315]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.315]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.315]                         "release", "version")], collapse = " "), 
  [03:00:25.315]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.315]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.315]                       info)
  [03:00:25.315]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.315]                     if (!has_future) {
  [03:00:25.315]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.315]                         info)
  [03:00:25.315]                     }
  [03:00:25.315]                     else {
  [03:00:25.315]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.315]                         info, version)
  [03:00:25.315]                     }
  [03:00:25.315]                     base::stop(msg)
  [03:00:25.315]                   }
  [03:00:25.315]                 })
  [03:00:25.315]             }
  [03:00:25.315]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.315]         }
  [03:00:25.315]     }
  [03:00:25.315]     if (base::is.na(NA)) {
  [03:00:25.315]     }
  [03:00:25.315]     else {
  [03:00:25.315]         if (NA) {
  [03:00:25.315]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.315]                 open = "w")
  [03:00:25.315]         }
  [03:00:25.315]         else {
  [03:00:25.315]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.315]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.315]         }
  [03:00:25.315]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.315]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.315]             base::sink(type = "output", split = FALSE)
  [03:00:25.315]             base::close(...future.stdout)
  [03:00:25.315]         }, add = TRUE)
  [03:00:25.315]     }
  [03:00:25.315]     ...future.frame <- base::sys.nframe()
  [03:00:25.315]     ...future.conditions <- base::list()
  [03:00:25.315]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.315]     ...future.result <- base::tryCatch({
  [03:00:25.315]         base::withCallingHandlers({
  [03:00:25.315]             ...future.value <- base::withVisible(base::local({
  [03:00:25.315]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.315]             }))
  [03:00:25.315]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.315]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.315]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.315]                 version = "1.8")
  [03:00:25.315]         }, condition = base::local({
  [03:00:25.315]             c <- base::c
  [03:00:25.315]             inherits <- base::inherits
  [03:00:25.315]             invokeRestart <- base::invokeRestart
  [03:00:25.315]             length <- base::length
  [03:00:25.315]             list <- base::list
  [03:00:25.315]             seq.int <- base::seq.int
  [03:00:25.315]             signalCondition <- base::signalCondition
  [03:00:25.315]             sys.calls <- base::sys.calls
  [03:00:25.315]             Sys.time <- base::Sys.time
  [03:00:25.315]             `[[` <- base::`[[`
  [03:00:25.315]             `+` <- base::`+`
  [03:00:25.315]             `<<-` <- base::`<<-`
  [03:00:25.315]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.315]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.315]                   3L)]
  [03:00:25.315]             }
  [03:00:25.315]             function(cond) {
  [03:00:25.315]                 if (inherits(cond, "error")) {
  [03:00:25.315]                   sessionInformation <- function() {
  [03:00:25.315]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.315]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.315]                       search = base::search(), system = base::Sys.info())
  [03:00:25.315]                   }
  [03:00:25.315]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.315]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.315]                     cond$call), session = sessionInformation(), 
  [03:00:25.315]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.315]                   signalCondition(cond)
  [03:00:25.315]                 }
  [03:00:25.315]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.315]                 ))) {
  [03:00:25.315]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.315]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.315]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.315]                   if (!signal) {
  [03:00:25.315]                     muffleCondition <- function (cond) 
  [03:00:25.315]                     {
  [03:00:25.315]                       inherits <- base::inherits
  [03:00:25.315]                       invokeRestart <- base::invokeRestart
  [03:00:25.315]                       muffled <- FALSE
  [03:00:25.315]                       if (inherits(cond, "message")) {
  [03:00:25.315]                         invokeRestart("muffleMessage")
  [03:00:25.315]                         muffled <- TRUE
  [03:00:25.315]                       }
  [03:00:25.315]                       else if (inherits(cond, "warning")) {
  [03:00:25.315]                         invokeRestart("muffleWarning")
  [03:00:25.315]                         muffled <- TRUE
  [03:00:25.315]                       }
  [03:00:25.315]                       else if (inherits(cond, "condition")) {
  [03:00:25.315]                         computeRestarts <- base::computeRestarts
  [03:00:25.315]                         grepl <- base::grepl
  [03:00:25.315]                         is.null <- base::is.null
  [03:00:25.315]                         restarts <- computeRestarts(cond)
  [03:00:25.315]                         for (restart in restarts) {
  [03:00:25.315]                           name <- restart$name
  [03:00:25.315]                           if (is.null(name)) 
  [03:00:25.315]                             next
  [03:00:25.315]                           if (!grepl("^muffle", name)) 
  [03:00:25.315]                             next
  [03:00:25.315]                           invokeRestart(restart)
  [03:00:25.315]                           muffled <- TRUE
  [03:00:25.315]                           break
  [03:00:25.315]                         }
  [03:00:25.315]                       }
  [03:00:25.315]                       invisible(muffled)
  [03:00:25.315]                     }
  [03:00:25.315]                     muffleCondition(cond)
  [03:00:25.315]                   }
  [03:00:25.315]                 }
  [03:00:25.315]             }
  [03:00:25.315]         }))
  [03:00:25.315]     }, error = function(ex) {
  [03:00:25.315]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.315]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.315]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.315]     }, finally = {
  [03:00:25.315]         {
  [03:00:25.315]             NULL
  [03:00:25.315]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.315]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.315]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.315]                 label = NULL, ...) 
  [03:00:25.315]             {
  [03:00:25.315]                 if (substitute) 
  [03:00:25.315]                   expr <- substitute(expr)
  [03:00:25.315]                 local <- as.logical(local)
  [03:00:25.315]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.315]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.315]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.315]                   label = label, ...)
  [03:00:25.315]                 if (!future$lazy) 
  [03:00:25.315]                   future <- run(future)
  [03:00:25.315]                 invisible(future)
  [03:00:25.315]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.315]         }
  [03:00:25.315]         base::options(...future.oldOptions)
  [03:00:25.315]     })
  [03:00:25.315]     Sys.time
  [03:00:25.315]     if (base::is.na(NA)) {
  [03:00:25.315]     }
  [03:00:25.315]     else {
  [03:00:25.315]         base::sink(type = "output", split = FALSE)
  [03:00:25.315]         if (NA) {
  [03:00:25.315]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.315]         }
  [03:00:25.315]         else {
  [03:00:25.315]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.315]         }
  [03:00:25.315]         base::close(...future.stdout)
  [03:00:25.315]         ...future.stdout <- NULL
  [03:00:25.315]     }
  [03:00:25.315]     ...future.result$conditions <- ...future.conditions
  [03:00:25.315]     ...future.result
  [03:00:25.315] }
  [03:00:25.324] plan(): Setting new future strategy stack:
  [03:00:25.325] List of future strategies:
  [03:00:25.325] 1. sequential:
  [03:00:25.325]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.325]    - tweaked: FALSE
  [03:00:25.325]    - call: NULL
  [03:00:25.333] plan(): nbrOfWorkers() = 1
  [03:00:25.338] Packages needed by the future expression (n = 0): <none>
  [03:00:25.340] Packages needed by future strategies (n = 0): <none>
  [03:00:25.349] {
  [03:00:25.349]     {
  [03:00:25.349]         ...future.startTime <- base::Sys.time()
  [03:00:25.349]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.349]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.349]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.349]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.349]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.349]         {
  [03:00:25.349]             {
  [03:00:25.349]                 base::local({
  [03:00:25.349]                   has_future <- base::requireNamespace("future", 
  [03:00:25.349]                     quietly = TRUE)
  [03:00:25.349]                   version <- if (has_future) 
  [03:00:25.349]                     utils::packageVersion("future")
  [03:00:25.349]                   else NULL
  [03:00:25.349]                   if (!has_future || version < "1.8.0") {
  [03:00:25.349]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.349]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.349]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.349]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.349]                         "release", "version")], collapse = " "), 
  [03:00:25.349]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.349]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.349]                       info)
  [03:00:25.349]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.349]                     if (!has_future) {
  [03:00:25.349]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.349]                         info)
  [03:00:25.349]                     }
  [03:00:25.349]                     else {
  [03:00:25.349]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.349]                         info, version)
  [03:00:25.349]                     }
  [03:00:25.349]                     base::stop(msg)
  [03:00:25.349]                   }
  [03:00:25.349]                 })
  [03:00:25.349]             }
  [03:00:25.349]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.349]         }
  [03:00:25.349]     }
  [03:00:25.349]     if (base::is.na(NA)) {
  [03:00:25.349]     }
  [03:00:25.349]     else {
  [03:00:25.349]         if (NA) {
  [03:00:25.349]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.349]                 open = "w")
  [03:00:25.349]         }
  [03:00:25.349]         else {
  [03:00:25.349]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.349]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.349]         }
  [03:00:25.349]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.349]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.349]             base::sink(type = "output", split = FALSE)
  [03:00:25.349]             base::close(...future.stdout)
  [03:00:25.349]         }, add = TRUE)
  [03:00:25.349]     }
  [03:00:25.349]     ...future.frame <- base::sys.nframe()
  [03:00:25.349]     ...future.conditions <- base::list()
  [03:00:25.349]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.349]     ...future.result <- base::tryCatch({
  [03:00:25.349]         base::withCallingHandlers({
  [03:00:25.349]             ...future.value <- base::withVisible(base::local({
  [03:00:25.349]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.349]             }))
  [03:00:25.349]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.349]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.349]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.349]                 version = "1.8")
  [03:00:25.349]         }, condition = base::local({
  [03:00:25.349]             c <- base::c
  [03:00:25.349]             inherits <- base::inherits
  [03:00:25.349]             invokeRestart <- base::invokeRestart
  [03:00:25.349]             length <- base::length
  [03:00:25.349]             list <- base::list
  [03:00:25.349]             seq.int <- base::seq.int
  [03:00:25.349]             signalCondition <- base::signalCondition
  [03:00:25.349]             sys.calls <- base::sys.calls
  [03:00:25.349]             Sys.time <- base::Sys.time
  [03:00:25.349]             `[[` <- base::`[[`
  [03:00:25.349]             `+` <- base::`+`
  [03:00:25.349]             `<<-` <- base::`<<-`
  [03:00:25.349]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.349]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.349]                   3L)]
  [03:00:25.349]             }
  [03:00:25.349]             function(cond) {
  [03:00:25.349]                 if (inherits(cond, "error")) {
  [03:00:25.349]                   sessionInformation <- function() {
  [03:00:25.349]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.349]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.349]                       search = base::search(), system = base::Sys.info())
  [03:00:25.349]                   }
  [03:00:25.349]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.349]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.349]                     cond$call), session = sessionInformation(), 
  [03:00:25.349]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.349]                   signalCondition(cond)
  [03:00:25.349]                 }
  [03:00:25.349]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.349]                 ))) {
  [03:00:25.349]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.349]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.349]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.349]                   if (!signal) {
  [03:00:25.349]                     muffleCondition <- function (cond) 
  [03:00:25.349]                     {
  [03:00:25.349]                       inherits <- base::inherits
  [03:00:25.349]                       invokeRestart <- base::invokeRestart
  [03:00:25.349]                       muffled <- FALSE
  [03:00:25.349]                       if (inherits(cond, "message")) {
  [03:00:25.349]                         invokeRestart("muffleMessage")
  [03:00:25.349]                         muffled <- TRUE
  [03:00:25.349]                       }
  [03:00:25.349]                       else if (inherits(cond, "warning")) {
  [03:00:25.349]                         invokeRestart("muffleWarning")
  [03:00:25.349]                         muffled <- TRUE
  [03:00:25.349]                       }
  [03:00:25.349]                       else if (inherits(cond, "condition")) {
  [03:00:25.349]                         computeRestarts <- base::computeRestarts
  [03:00:25.349]                         grepl <- base::grepl
  [03:00:25.349]                         is.null <- base::is.null
  [03:00:25.349]                         restarts <- computeRestarts(cond)
  [03:00:25.349]                         for (restart in restarts) {
  [03:00:25.349]                           name <- restart$name
  [03:00:25.349]                           if (is.null(name)) 
  [03:00:25.349]                             next
  [03:00:25.349]                           if (!grepl("^muffle", name)) 
  [03:00:25.349]                             next
  [03:00:25.349]                           invokeRestart(restart)
  [03:00:25.349]                           muffled <- TRUE
  [03:00:25.349]                           break
  [03:00:25.349]                         }
  [03:00:25.349]                       }
  [03:00:25.349]                       invisible(muffled)
  [03:00:25.349]                     }
  [03:00:25.349]                     muffleCondition(cond)
  [03:00:25.349]                   }
  [03:00:25.349]                 }
  [03:00:25.349]             }
  [03:00:25.349]         }))
  [03:00:25.349]     }, error = function(ex) {
  [03:00:25.349]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.349]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.349]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.349]     }, finally = {
  [03:00:25.349]         {
  [03:00:25.349]             NULL
  [03:00:25.349]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.349]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.349]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.349]                 label = NULL, ...) 
  [03:00:25.349]             {
  [03:00:25.349]                 if (substitute) 
  [03:00:25.349]                   expr <- substitute(expr)
  [03:00:25.349]                 local <- as.logical(local)
  [03:00:25.349]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.349]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.349]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.349]                   label = label, ...)
  [03:00:25.349]                 if (!future$lazy) 
  [03:00:25.349]                   future <- run(future)
  [03:00:25.349]                 invisible(future)
  [03:00:25.349]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.349]         }
  [03:00:25.349]         base::options(...future.oldOptions)
  [03:00:25.349]     })
  [03:00:25.349]     Sys.time
  [03:00:25.349]     if (base::is.na(NA)) {
  [03:00:25.349]     }
  [03:00:25.349]     else {
  [03:00:25.349]         base::sink(type = "output", split = FALSE)
  [03:00:25.349]         if (NA) {
  [03:00:25.349]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.349]         }
  [03:00:25.349]         else {
  [03:00:25.349]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.349]         }
  [03:00:25.349]         base::close(...future.stdout)
  [03:00:25.349]         ...future.stdout <- NULL
  [03:00:25.349]     }
  [03:00:25.349]     ...future.result$conditions <- ...future.conditions
  [03:00:25.349]     ...future.result
  [03:00:25.349] }
  [03:00:25.358] plan(): Setting new future strategy stack:
  [03:00:25.360] List of future strategies:
  [03:00:25.360] 1. sequential:
  [03:00:25.360]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.360]    - tweaked: FALSE
  [03:00:25.360]    - call: NULL
  [03:00:25.363] plan(): nbrOfWorkers() = 1
  [03:00:25.368] Packages needed by the future expression (n = 0): <none>
  [03:00:25.370] Packages needed by future strategies (n = 0): <none>
  [03:00:25.378] {
  [03:00:25.378]     {
  [03:00:25.378]         ...future.startTime <- base::Sys.time()
  [03:00:25.378]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.378]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.378]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.378]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.378]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.378]         {
  [03:00:25.378]             {
  [03:00:25.378]                 base::local({
  [03:00:25.378]                   has_future <- base::requireNamespace("future", 
  [03:00:25.378]                     quietly = TRUE)
  [03:00:25.378]                   version <- if (has_future) 
  [03:00:25.378]                     utils::packageVersion("future")
  [03:00:25.378]                   else NULL
  [03:00:25.378]                   if (!has_future || version < "1.8.0") {
  [03:00:25.378]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.378]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.378]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.378]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.378]                         "release", "version")], collapse = " "), 
  [03:00:25.378]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.378]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.378]                       info)
  [03:00:25.378]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.378]                     if (!has_future) {
  [03:00:25.378]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.378]                         info)
  [03:00:25.378]                     }
  [03:00:25.378]                     else {
  [03:00:25.378]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.378]                         info, version)
  [03:00:25.378]                     }
  [03:00:25.378]                     base::stop(msg)
  [03:00:25.378]                   }
  [03:00:25.378]                 })
  [03:00:25.378]             }
  [03:00:25.378]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.378]         }
  [03:00:25.378]     }
  [03:00:25.378]     if (base::is.na(NA)) {
  [03:00:25.378]     }
  [03:00:25.378]     else {
  [03:00:25.378]         if (NA) {
  [03:00:25.378]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.378]                 open = "w")
  [03:00:25.378]         }
  [03:00:25.378]         else {
  [03:00:25.378]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.378]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.378]         }
  [03:00:25.378]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.378]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.378]             base::sink(type = "output", split = FALSE)
  [03:00:25.378]             base::close(...future.stdout)
  [03:00:25.378]         }, add = TRUE)
  [03:00:25.378]     }
  [03:00:25.378]     ...future.frame <- base::sys.nframe()
  [03:00:25.378]     ...future.conditions <- base::list()
  [03:00:25.378]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.378]     ...future.result <- base::tryCatch({
  [03:00:25.378]         base::withCallingHandlers({
  [03:00:25.378]             ...future.value <- base::withVisible(base::local({
  [03:00:25.378]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.378]             }))
  [03:00:25.378]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.378]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.378]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.378]                 version = "1.8")
  [03:00:25.378]         }, condition = base::local({
  [03:00:25.378]             c <- base::c
  [03:00:25.378]             inherits <- base::inherits
  [03:00:25.378]             invokeRestart <- base::invokeRestart
  [03:00:25.378]             length <- base::length
  [03:00:25.378]             list <- base::list
  [03:00:25.378]             seq.int <- base::seq.int
  [03:00:25.378]             signalCondition <- base::signalCondition
  [03:00:25.378]             sys.calls <- base::sys.calls
  [03:00:25.378]             Sys.time <- base::Sys.time
  [03:00:25.378]             `[[` <- base::`[[`
  [03:00:25.378]             `+` <- base::`+`
  [03:00:25.378]             `<<-` <- base::`<<-`
  [03:00:25.378]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.378]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.378]                   3L)]
  [03:00:25.378]             }
  [03:00:25.378]             function(cond) {
  [03:00:25.378]                 if (inherits(cond, "error")) {
  [03:00:25.378]                   sessionInformation <- function() {
  [03:00:25.378]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.378]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.378]                       search = base::search(), system = base::Sys.info())
  [03:00:25.378]                   }
  [03:00:25.378]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.378]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.378]                     cond$call), session = sessionInformation(), 
  [03:00:25.378]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.378]                   signalCondition(cond)
  [03:00:25.378]                 }
  [03:00:25.378]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.378]                 ))) {
  [03:00:25.378]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.378]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.378]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.378]                   if (!signal) {
  [03:00:25.378]                     muffleCondition <- function (cond) 
  [03:00:25.378]                     {
  [03:00:25.378]                       inherits <- base::inherits
  [03:00:25.378]                       invokeRestart <- base::invokeRestart
  [03:00:25.378]                       muffled <- FALSE
  [03:00:25.378]                       if (inherits(cond, "message")) {
  [03:00:25.378]                         invokeRestart("muffleMessage")
  [03:00:25.378]                         muffled <- TRUE
  [03:00:25.378]                       }
  [03:00:25.378]                       else if (inherits(cond, "warning")) {
  [03:00:25.378]                         invokeRestart("muffleWarning")
  [03:00:25.378]                         muffled <- TRUE
  [03:00:25.378]                       }
  [03:00:25.378]                       else if (inherits(cond, "condition")) {
  [03:00:25.378]                         computeRestarts <- base::computeRestarts
  [03:00:25.378]                         grepl <- base::grepl
  [03:00:25.378]                         is.null <- base::is.null
  [03:00:25.378]                         restarts <- computeRestarts(cond)
  [03:00:25.378]                         for (restart in restarts) {
  [03:00:25.378]                           name <- restart$name
  [03:00:25.378]                           if (is.null(name)) 
  [03:00:25.378]                             next
  [03:00:25.378]                           if (!grepl("^muffle", name)) 
  [03:00:25.378]                             next
  [03:00:25.378]                           invokeRestart(restart)
  [03:00:25.378]                           muffled <- TRUE
  [03:00:25.378]                           break
  [03:00:25.378]                         }
  [03:00:25.378]                       }
  [03:00:25.378]                       invisible(muffled)
  [03:00:25.378]                     }
  [03:00:25.378]                     muffleCondition(cond)
  [03:00:25.378]                   }
  [03:00:25.378]                 }
  [03:00:25.378]             }
  [03:00:25.378]         }))
  [03:00:25.378]     }, error = function(ex) {
  [03:00:25.378]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.378]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.378]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.378]     }, finally = {
  [03:00:25.378]         {
  [03:00:25.378]             NULL
  [03:00:25.378]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.378]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.378]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.378]                 label = NULL, ...) 
  [03:00:25.378]             {
  [03:00:25.378]                 if (substitute) 
  [03:00:25.378]                   expr <- substitute(expr)
  [03:00:25.378]                 local <- as.logical(local)
  [03:00:25.378]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.378]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.378]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.378]                   label = label, ...)
  [03:00:25.378]                 if (!future$lazy) 
  [03:00:25.378]                   future <- run(future)
  [03:00:25.378]                 invisible(future)
  [03:00:25.378]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.378]         }
  [03:00:25.378]         base::options(...future.oldOptions)
  [03:00:25.378]     })
  [03:00:25.378]     Sys.time
  [03:00:25.378]     if (base::is.na(NA)) {
  [03:00:25.378]     }
  [03:00:25.378]     else {
  [03:00:25.378]         base::sink(type = "output", split = FALSE)
  [03:00:25.378]         if (NA) {
  [03:00:25.378]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.378]         }
  [03:00:25.378]         else {
  [03:00:25.378]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.378]         }
  [03:00:25.378]         base::close(...future.stdout)
  [03:00:25.378]         ...future.stdout <- NULL
  [03:00:25.378]     }
  [03:00:25.378]     ...future.result$conditions <- ...future.conditions
  [03:00:25.378]     ...future.result
  [03:00:25.378] }
  [03:00:25.387] plan(): Setting new future strategy stack:
  [03:00:25.389] List of future strategies:
  [03:00:25.389] 1. sequential:
  [03:00:25.389]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.389]    - tweaked: FALSE
  [03:00:25.389]    - call: NULL
  [03:00:25.392] plan(): nbrOfWorkers() = 1
  [03:00:25.396] Packages needed by the future expression (n = 0): <none>
  [03:00:25.399] Packages needed by future strategies (n = 0): <none>
  [03:00:25.408] {
  [03:00:25.408]     {
  [03:00:25.408]         ...future.startTime <- base::Sys.time()
  [03:00:25.408]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.408]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.408]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.408]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.408]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.408]         {
  [03:00:25.408]             {
  [03:00:25.408]                 base::local({
  [03:00:25.408]                   has_future <- base::requireNamespace("future", 
  [03:00:25.408]                     quietly = TRUE)
  [03:00:25.408]                   version <- if (has_future) 
  [03:00:25.408]                     utils::packageVersion("future")
  [03:00:25.408]                   else NULL
  [03:00:25.408]                   if (!has_future || version < "1.8.0") {
  [03:00:25.408]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.408]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.408]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.408]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.408]                         "release", "version")], collapse = " "), 
  [03:00:25.408]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.408]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.408]                       info)
  [03:00:25.408]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.408]                     if (!has_future) {
  [03:00:25.408]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.408]                         info)
  [03:00:25.408]                     }
  [03:00:25.408]                     else {
  [03:00:25.408]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.408]                         info, version)
  [03:00:25.408]                     }
  [03:00:25.408]                     base::stop(msg)
  [03:00:25.408]                   }
  [03:00:25.408]                 })
  [03:00:25.408]             }
  [03:00:25.408]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.408]         }
  [03:00:25.408]     }
  [03:00:25.408]     if (base::is.na(NA)) {
  [03:00:25.408]     }
  [03:00:25.408]     else {
  [03:00:25.408]         if (NA) {
  [03:00:25.408]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.408]                 open = "w")
  [03:00:25.408]         }
  [03:00:25.408]         else {
  [03:00:25.408]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.408]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.408]         }
  [03:00:25.408]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.408]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.408]             base::sink(type = "output", split = FALSE)
  [03:00:25.408]             base::close(...future.stdout)
  [03:00:25.408]         }, add = TRUE)
  [03:00:25.408]     }
  [03:00:25.408]     ...future.frame <- base::sys.nframe()
  [03:00:25.408]     ...future.conditions <- base::list()
  [03:00:25.408]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.408]     ...future.result <- base::tryCatch({
  [03:00:25.408]         base::withCallingHandlers({
  [03:00:25.408]             ...future.value <- base::withVisible(base::local({
  [03:00:25.408]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.408]             }))
  [03:00:25.408]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.408]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.408]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.408]                 version = "1.8")
  [03:00:25.408]         }, condition = base::local({
  [03:00:25.408]             c <- base::c
  [03:00:25.408]             inherits <- base::inherits
  [03:00:25.408]             invokeRestart <- base::invokeRestart
  [03:00:25.408]             length <- base::length
  [03:00:25.408]             list <- base::list
  [03:00:25.408]             seq.int <- base::seq.int
  [03:00:25.408]             signalCondition <- base::signalCondition
  [03:00:25.408]             sys.calls <- base::sys.calls
  [03:00:25.408]             Sys.time <- base::Sys.time
  [03:00:25.408]             `[[` <- base::`[[`
  [03:00:25.408]             `+` <- base::`+`
  [03:00:25.408]             `<<-` <- base::`<<-`
  [03:00:25.408]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.408]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.408]                   3L)]
  [03:00:25.408]             }
  [03:00:25.408]             function(cond) {
  [03:00:25.408]                 if (inherits(cond, "error")) {
  [03:00:25.408]                   sessionInformation <- function() {
  [03:00:25.408]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.408]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.408]                       search = base::search(), system = base::Sys.info())
  [03:00:25.408]                   }
  [03:00:25.408]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.408]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.408]                     cond$call), session = sessionInformation(), 
  [03:00:25.408]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.408]                   signalCondition(cond)
  [03:00:25.408]                 }
  [03:00:25.408]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.408]                 ))) {
  [03:00:25.408]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.408]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.408]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.408]                   if (!signal) {
  [03:00:25.408]                     muffleCondition <- function (cond) 
  [03:00:25.408]                     {
  [03:00:25.408]                       inherits <- base::inherits
  [03:00:25.408]                       invokeRestart <- base::invokeRestart
  [03:00:25.408]                       muffled <- FALSE
  [03:00:25.408]                       if (inherits(cond, "message")) {
  [03:00:25.408]                         invokeRestart("muffleMessage")
  [03:00:25.408]                         muffled <- TRUE
  [03:00:25.408]                       }
  [03:00:25.408]                       else if (inherits(cond, "warning")) {
  [03:00:25.408]                         invokeRestart("muffleWarning")
  [03:00:25.408]                         muffled <- TRUE
  [03:00:25.408]                       }
  [03:00:25.408]                       else if (inherits(cond, "condition")) {
  [03:00:25.408]                         computeRestarts <- base::computeRestarts
  [03:00:25.408]                         grepl <- base::grepl
  [03:00:25.408]                         is.null <- base::is.null
  [03:00:25.408]                         restarts <- computeRestarts(cond)
  [03:00:25.408]                         for (restart in restarts) {
  [03:00:25.408]                           name <- restart$name
  [03:00:25.408]                           if (is.null(name)) 
  [03:00:25.408]                             next
  [03:00:25.408]                           if (!grepl("^muffle", name)) 
  [03:00:25.408]                             next
  [03:00:25.408]                           invokeRestart(restart)
  [03:00:25.408]                           muffled <- TRUE
  [03:00:25.408]                           break
  [03:00:25.408]                         }
  [03:00:25.408]                       }
  [03:00:25.408]                       invisible(muffled)
  [03:00:25.408]                     }
  [03:00:25.408]                     muffleCondition(cond)
  [03:00:25.408]                   }
  [03:00:25.408]                 }
  [03:00:25.408]             }
  [03:00:25.408]         }))
  [03:00:25.408]     }, error = function(ex) {
  [03:00:25.408]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.408]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.408]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.408]     }, finally = {
  [03:00:25.408]         {
  [03:00:25.408]             NULL
  [03:00:25.408]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.408]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.408]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.408]                 label = NULL, ...) 
  [03:00:25.408]             {
  [03:00:25.408]                 if (substitute) 
  [03:00:25.408]                   expr <- substitute(expr)
  [03:00:25.408]                 local <- as.logical(local)
  [03:00:25.408]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.408]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.408]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.408]                   label = label, ...)
  [03:00:25.408]                 if (!future$lazy) 
  [03:00:25.408]                   future <- run(future)
  [03:00:25.408]                 invisible(future)
  [03:00:25.408]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.408]         }
  [03:00:25.408]         base::options(...future.oldOptions)
  [03:00:25.408]     })
  [03:00:25.408]     Sys.time
  [03:00:25.408]     if (base::is.na(NA)) {
  [03:00:25.408]     }
  [03:00:25.408]     else {
  [03:00:25.408]         base::sink(type = "output", split = FALSE)
  [03:00:25.408]         if (NA) {
  [03:00:25.408]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.408]         }
  [03:00:25.408]         else {
  [03:00:25.408]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.408]         }
  [03:00:25.408]         base::close(...future.stdout)
  [03:00:25.408]         ...future.stdout <- NULL
  [03:00:25.408]     }
  [03:00:25.408]     ...future.result$conditions <- ...future.conditions
  [03:00:25.408]     ...future.result
  [03:00:25.408] }
  [03:00:25.417] plan(): Setting new future strategy stack:
  [03:00:25.419] List of future strategies:
  [03:00:25.419] 1. sequential:
  [03:00:25.419]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.419]    - tweaked: FALSE
  [03:00:25.419]    - call: NULL
  [03:00:25.422] plan(): nbrOfWorkers() = 1
  [03:00:25.427] Packages needed by the future expression (n = 0): <none>
  [03:00:25.430] Packages needed by future strategies (n = 0): <none>
  [03:00:25.438] {
  [03:00:25.438]     {
  [03:00:25.438]         ...future.startTime <- base::Sys.time()
  [03:00:25.438]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.438]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.438]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.438]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.438]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.438]         {
  [03:00:25.438]             {
  [03:00:25.438]                 base::local({
  [03:00:25.438]                   has_future <- base::requireNamespace("future", 
  [03:00:25.438]                     quietly = TRUE)
  [03:00:25.438]                   version <- if (has_future) 
  [03:00:25.438]                     utils::packageVersion("future")
  [03:00:25.438]                   else NULL
  [03:00:25.438]                   if (!has_future || version < "1.8.0") {
  [03:00:25.438]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.438]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.438]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.438]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.438]                         "release", "version")], collapse = " "), 
  [03:00:25.438]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.438]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.438]                       info)
  [03:00:25.438]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.438]                     if (!has_future) {
  [03:00:25.438]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.438]                         info)
  [03:00:25.438]                     }
  [03:00:25.438]                     else {
  [03:00:25.438]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.438]                         info, version)
  [03:00:25.438]                     }
  [03:00:25.438]                     base::stop(msg)
  [03:00:25.438]                   }
  [03:00:25.438]                 })
  [03:00:25.438]             }
  [03:00:25.438]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.438]         }
  [03:00:25.438]     }
  [03:00:25.438]     if (base::is.na(NA)) {
  [03:00:25.438]     }
  [03:00:25.438]     else {
  [03:00:25.438]         if (NA) {
  [03:00:25.438]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.438]                 open = "w")
  [03:00:25.438]         }
  [03:00:25.438]         else {
  [03:00:25.438]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.438]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.438]         }
  [03:00:25.438]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.438]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.438]             base::sink(type = "output", split = FALSE)
  [03:00:25.438]             base::close(...future.stdout)
  [03:00:25.438]         }, add = TRUE)
  [03:00:25.438]     }
  [03:00:25.438]     ...future.frame <- base::sys.nframe()
  [03:00:25.438]     ...future.conditions <- base::list()
  [03:00:25.438]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.438]     ...future.result <- base::tryCatch({
  [03:00:25.438]         base::withCallingHandlers({
  [03:00:25.438]             ...future.value <- base::withVisible(base::local({
  [03:00:25.438]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.438]             }))
  [03:00:25.438]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.438]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.438]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.438]                 version = "1.8")
  [03:00:25.438]         }, condition = base::local({
  [03:00:25.438]             c <- base::c
  [03:00:25.438]             inherits <- base::inherits
  [03:00:25.438]             invokeRestart <- base::invokeRestart
  [03:00:25.438]             length <- base::length
  [03:00:25.438]             list <- base::list
  [03:00:25.438]             seq.int <- base::seq.int
  [03:00:25.438]             signalCondition <- base::signalCondition
  [03:00:25.438]             sys.calls <- base::sys.calls
  [03:00:25.438]             Sys.time <- base::Sys.time
  [03:00:25.438]             `[[` <- base::`[[`
  [03:00:25.438]             `+` <- base::`+`
  [03:00:25.438]             `<<-` <- base::`<<-`
  [03:00:25.438]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.438]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.438]                   3L)]
  [03:00:25.438]             }
  [03:00:25.438]             function(cond) {
  [03:00:25.438]                 if (inherits(cond, "error")) {
  [03:00:25.438]                   sessionInformation <- function() {
  [03:00:25.438]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.438]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.438]                       search = base::search(), system = base::Sys.info())
  [03:00:25.438]                   }
  [03:00:25.438]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.438]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.438]                     cond$call), session = sessionInformation(), 
  [03:00:25.438]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.438]                   signalCondition(cond)
  [03:00:25.438]                 }
  [03:00:25.438]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.438]                 ))) {
  [03:00:25.438]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.438]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.438]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.438]                   if (!signal) {
  [03:00:25.438]                     muffleCondition <- function (cond) 
  [03:00:25.438]                     {
  [03:00:25.438]                       inherits <- base::inherits
  [03:00:25.438]                       invokeRestart <- base::invokeRestart
  [03:00:25.438]                       muffled <- FALSE
  [03:00:25.438]                       if (inherits(cond, "message")) {
  [03:00:25.438]                         invokeRestart("muffleMessage")
  [03:00:25.438]                         muffled <- TRUE
  [03:00:25.438]                       }
  [03:00:25.438]                       else if (inherits(cond, "warning")) {
  [03:00:25.438]                         invokeRestart("muffleWarning")
  [03:00:25.438]                         muffled <- TRUE
  [03:00:25.438]                       }
  [03:00:25.438]                       else if (inherits(cond, "condition")) {
  [03:00:25.438]                         computeRestarts <- base::computeRestarts
  [03:00:25.438]                         grepl <- base::grepl
  [03:00:25.438]                         is.null <- base::is.null
  [03:00:25.438]                         restarts <- computeRestarts(cond)
  [03:00:25.438]                         for (restart in restarts) {
  [03:00:25.438]                           name <- restart$name
  [03:00:25.438]                           if (is.null(name)) 
  [03:00:25.438]                             next
  [03:00:25.438]                           if (!grepl("^muffle", name)) 
  [03:00:25.438]                             next
  [03:00:25.438]                           invokeRestart(restart)
  [03:00:25.438]                           muffled <- TRUE
  [03:00:25.438]                           break
  [03:00:25.438]                         }
  [03:00:25.438]                       }
  [03:00:25.438]                       invisible(muffled)
  [03:00:25.438]                     }
  [03:00:25.438]                     muffleCondition(cond)
  [03:00:25.438]                   }
  [03:00:25.438]                 }
  [03:00:25.438]             }
  [03:00:25.438]         }))
  [03:00:25.438]     }, error = function(ex) {
  [03:00:25.438]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.438]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.438]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.438]     }, finally = {
  [03:00:25.438]         {
  [03:00:25.438]             NULL
  [03:00:25.438]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.438]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.438]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.438]                 label = NULL, ...) 
  [03:00:25.438]             {
  [03:00:25.438]                 if (substitute) 
  [03:00:25.438]                   expr <- substitute(expr)
  [03:00:25.438]                 local <- as.logical(local)
  [03:00:25.438]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.438]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.438]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.438]                   label = label, ...)
  [03:00:25.438]                 if (!future$lazy) 
  [03:00:25.438]                   future <- run(future)
  [03:00:25.438]                 invisible(future)
  [03:00:25.438]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.438]         }
  [03:00:25.438]         base::options(...future.oldOptions)
  [03:00:25.438]     })
  [03:00:25.438]     Sys.time
  [03:00:25.438]     if (base::is.na(NA)) {
  [03:00:25.438]     }
  [03:00:25.438]     else {
  [03:00:25.438]         base::sink(type = "output", split = FALSE)
  [03:00:25.438]         if (NA) {
  [03:00:25.438]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.438]         }
  [03:00:25.438]         else {
  [03:00:25.438]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.438]         }
  [03:00:25.438]         base::close(...future.stdout)
  [03:00:25.438]         ...future.stdout <- NULL
  [03:00:25.438]     }
  [03:00:25.438]     ...future.result$conditions <- ...future.conditions
  [03:00:25.438]     ...future.result
  [03:00:25.438] }
  [03:00:25.447] plan(): Setting new future strategy stack:
  [03:00:25.450] List of future strategies:
  [03:00:25.450] 1. sequential:
  [03:00:25.450]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.450]    - tweaked: FALSE
  [03:00:25.450]    - call: NULL
  [03:00:25.453] plan(): nbrOfWorkers() = 1
  [03:00:25.464] Packages needed by the future expression (n = 0): <none>
  [03:00:25.467] Packages needed by future strategies (n = 0): <none>
  [03:00:25.477] {
  [03:00:25.477]     {
  [03:00:25.477]         ...future.startTime <- base::Sys.time()
  [03:00:25.477]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.477]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.477]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.477]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.477]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.477]         {
  [03:00:25.477]             {
  [03:00:25.477]                 base::local({
  [03:00:25.477]                   has_future <- base::requireNamespace("future", 
  [03:00:25.477]                     quietly = TRUE)
  [03:00:25.477]                   version <- if (has_future) 
  [03:00:25.477]                     utils::packageVersion("future")
  [03:00:25.477]                   else NULL
  [03:00:25.477]                   if (!has_future || version < "1.8.0") {
  [03:00:25.477]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.477]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.477]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.477]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.477]                         "release", "version")], collapse = " "), 
  [03:00:25.477]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.477]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.477]                       info)
  [03:00:25.477]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.477]                     if (!has_future) {
  [03:00:25.477]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.477]                         info)
  [03:00:25.477]                     }
  [03:00:25.477]                     else {
  [03:00:25.477]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.477]                         info, version)
  [03:00:25.477]                     }
  [03:00:25.477]                     base::stop(msg)
  [03:00:25.477]                   }
  [03:00:25.477]                 })
  [03:00:25.477]             }
  [03:00:25.477]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.477]         }
  [03:00:25.477]     }
  [03:00:25.477]     if (base::is.na(NA)) {
  [03:00:25.477]     }
  [03:00:25.477]     else {
  [03:00:25.477]         if (NA) {
  [03:00:25.477]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.477]                 open = "w")
  [03:00:25.477]         }
  [03:00:25.477]         else {
  [03:00:25.477]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.477]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.477]         }
  [03:00:25.477]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.477]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.477]             base::sink(type = "output", split = FALSE)
  [03:00:25.477]             base::close(...future.stdout)
  [03:00:25.477]         }, add = TRUE)
  [03:00:25.477]     }
  [03:00:25.477]     ...future.frame <- base::sys.nframe()
  [03:00:25.477]     ...future.conditions <- base::list()
  [03:00:25.477]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.477]     ...future.result <- base::tryCatch({
  [03:00:25.477]         base::withCallingHandlers({
  [03:00:25.477]             ...future.value <- base::withVisible(base::local({
  [03:00:25.477]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.477]             }))
  [03:00:25.477]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.477]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.477]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.477]                 version = "1.8")
  [03:00:25.477]         }, condition = base::local({
  [03:00:25.477]             c <- base::c
  [03:00:25.477]             inherits <- base::inherits
  [03:00:25.477]             invokeRestart <- base::invokeRestart
  [03:00:25.477]             length <- base::length
  [03:00:25.477]             list <- base::list
  [03:00:25.477]             seq.int <- base::seq.int
  [03:00:25.477]             signalCondition <- base::signalCondition
  [03:00:25.477]             sys.calls <- base::sys.calls
  [03:00:25.477]             Sys.time <- base::Sys.time
  [03:00:25.477]             `[[` <- base::`[[`
  [03:00:25.477]             `+` <- base::`+`
  [03:00:25.477]             `<<-` <- base::`<<-`
  [03:00:25.477]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.477]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.477]                   3L)]
  [03:00:25.477]             }
  [03:00:25.477]             function(cond) {
  [03:00:25.477]                 if (inherits(cond, "error")) {
  [03:00:25.477]                   sessionInformation <- function() {
  [03:00:25.477]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.477]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.477]                       search = base::search(), system = base::Sys.info())
  [03:00:25.477]                   }
  [03:00:25.477]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.477]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.477]                     cond$call), session = sessionInformation(), 
  [03:00:25.477]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.477]                   signalCondition(cond)
  [03:00:25.477]                 }
  [03:00:25.477]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.477]                 ))) {
  [03:00:25.477]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.477]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.477]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.477]                   if (!signal) {
  [03:00:25.477]                     muffleCondition <- function (cond) 
  [03:00:25.477]                     {
  [03:00:25.477]                       inherits <- base::inherits
  [03:00:25.477]                       invokeRestart <- base::invokeRestart
  [03:00:25.477]                       muffled <- FALSE
  [03:00:25.477]                       if (inherits(cond, "message")) {
  [03:00:25.477]                         invokeRestart("muffleMessage")
  [03:00:25.477]                         muffled <- TRUE
  [03:00:25.477]                       }
  [03:00:25.477]                       else if (inherits(cond, "warning")) {
  [03:00:25.477]                         invokeRestart("muffleWarning")
  [03:00:25.477]                         muffled <- TRUE
  [03:00:25.477]                       }
  [03:00:25.477]                       else if (inherits(cond, "condition")) {
  [03:00:25.477]                         computeRestarts <- base::computeRestarts
  [03:00:25.477]                         grepl <- base::grepl
  [03:00:25.477]                         is.null <- base::is.null
  [03:00:25.477]                         restarts <- computeRestarts(cond)
  [03:00:25.477]                         for (restart in restarts) {
  [03:00:25.477]                           name <- restart$name
  [03:00:25.477]                           if (is.null(name)) 
  [03:00:25.477]                             next
  [03:00:25.477]                           if (!grepl("^muffle", name)) 
  [03:00:25.477]                             next
  [03:00:25.477]                           invokeRestart(restart)
  [03:00:25.477]                           muffled <- TRUE
  [03:00:25.477]                           break
  [03:00:25.477]                         }
  [03:00:25.477]                       }
  [03:00:25.477]                       invisible(muffled)
  [03:00:25.477]                     }
  [03:00:25.477]                     muffleCondition(cond)
  [03:00:25.477]                   }
  [03:00:25.477]                 }
  [03:00:25.477]             }
  [03:00:25.477]         }))
  [03:00:25.477]     }, error = function(ex) {
  [03:00:25.477]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.477]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.477]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.477]     }, finally = {
  [03:00:25.477]         {
  [03:00:25.477]             NULL
  [03:00:25.477]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.477]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.477]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.477]                 label = NULL, ...) 
  [03:00:25.477]             {
  [03:00:25.477]                 if (substitute) 
  [03:00:25.477]                   expr <- substitute(expr)
  [03:00:25.477]                 local <- as.logical(local)
  [03:00:25.477]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.477]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.477]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.477]                   label = label, ...)
  [03:00:25.477]                 if (!future$lazy) 
  [03:00:25.477]                   future <- run(future)
  [03:00:25.477]                 invisible(future)
  [03:00:25.477]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.477]         }
  [03:00:25.477]         base::options(...future.oldOptions)
  [03:00:25.477]     })
  [03:00:25.477]     Sys.time
  [03:00:25.477]     if (base::is.na(NA)) {
  [03:00:25.477]     }
  [03:00:25.477]     else {
  [03:00:25.477]         base::sink(type = "output", split = FALSE)
  [03:00:25.477]         if (NA) {
  [03:00:25.477]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.477]         }
  [03:00:25.477]         else {
  [03:00:25.477]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.477]         }
  [03:00:25.477]         base::close(...future.stdout)
  [03:00:25.477]         ...future.stdout <- NULL
  [03:00:25.477]     }
  [03:00:25.477]     ...future.result$conditions <- ...future.conditions
  [03:00:25.477]     ...future.result
  [03:00:25.477] }
  [03:00:25.486] plan(): Setting new future strategy stack:
  [03:00:25.489] List of future strategies:
  [03:00:25.489] 1. sequential:
  [03:00:25.489]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.489]    - tweaked: FALSE
  [03:00:25.489]    - call: NULL
  [03:00:25.492] plan(): nbrOfWorkers() = 1
  [03:00:25.498] Packages needed by the future expression (n = 0): <none>
  [03:00:25.500] Packages needed by future strategies (n = 0): <none>
  [03:00:25.509] {
  [03:00:25.509]     {
  [03:00:25.509]         ...future.startTime <- base::Sys.time()
  [03:00:25.509]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.509]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.509]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.509]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.509]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.509]         {
  [03:00:25.509]             {
  [03:00:25.509]                 base::local({
  [03:00:25.509]                   has_future <- base::requireNamespace("future", 
  [03:00:25.509]                     quietly = TRUE)
  [03:00:25.509]                   version <- if (has_future) 
  [03:00:25.509]                     utils::packageVersion("future")
  [03:00:25.509]                   else NULL
  [03:00:25.509]                   if (!has_future || version < "1.8.0") {
  [03:00:25.509]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.509]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.509]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.509]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.509]                         "release", "version")], collapse = " "), 
  [03:00:25.509]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.509]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.509]                       info)
  [03:00:25.509]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.509]                     if (!has_future) {
  [03:00:25.509]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.509]                         info)
  [03:00:25.509]                     }
  [03:00:25.509]                     else {
  [03:00:25.509]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.509]                         info, version)
  [03:00:25.509]                     }
  [03:00:25.509]                     base::stop(msg)
  [03:00:25.509]                   }
  [03:00:25.509]                 })
  [03:00:25.509]             }
  [03:00:25.509]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.509]         }
  [03:00:25.509]     }
  [03:00:25.509]     if (base::is.na(NA)) {
  [03:00:25.509]     }
  [03:00:25.509]     else {
  [03:00:25.509]         if (NA) {
  [03:00:25.509]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.509]                 open = "w")
  [03:00:25.509]         }
  [03:00:25.509]         else {
  [03:00:25.509]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.509]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.509]         }
  [03:00:25.509]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.509]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.509]             base::sink(type = "output", split = FALSE)
  [03:00:25.509]             base::close(...future.stdout)
  [03:00:25.509]         }, add = TRUE)
  [03:00:25.509]     }
  [03:00:25.509]     ...future.frame <- base::sys.nframe()
  [03:00:25.509]     ...future.conditions <- base::list()
  [03:00:25.509]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.509]     ...future.result <- base::tryCatch({
  [03:00:25.509]         base::withCallingHandlers({
  [03:00:25.509]             ...future.value <- base::withVisible(base::local({
  [03:00:25.509]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.509]             }))
  [03:00:25.509]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.509]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.509]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.509]                 version = "1.8")
  [03:00:25.509]         }, condition = base::local({
  [03:00:25.509]             c <- base::c
  [03:00:25.509]             inherits <- base::inherits
  [03:00:25.509]             invokeRestart <- base::invokeRestart
  [03:00:25.509]             length <- base::length
  [03:00:25.509]             list <- base::list
  [03:00:25.509]             seq.int <- base::seq.int
  [03:00:25.509]             signalCondition <- base::signalCondition
  [03:00:25.509]             sys.calls <- base::sys.calls
  [03:00:25.509]             Sys.time <- base::Sys.time
  [03:00:25.509]             `[[` <- base::`[[`
  [03:00:25.509]             `+` <- base::`+`
  [03:00:25.509]             `<<-` <- base::`<<-`
  [03:00:25.509]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.509]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.509]                   3L)]
  [03:00:25.509]             }
  [03:00:25.509]             function(cond) {
  [03:00:25.509]                 if (inherits(cond, "error")) {
  [03:00:25.509]                   sessionInformation <- function() {
  [03:00:25.509]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.509]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.509]                       search = base::search(), system = base::Sys.info())
  [03:00:25.509]                   }
  [03:00:25.509]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.509]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.509]                     cond$call), session = sessionInformation(), 
  [03:00:25.509]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.509]                   signalCondition(cond)
  [03:00:25.509]                 }
  [03:00:25.509]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.509]                 ))) {
  [03:00:25.509]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.509]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.509]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.509]                   if (!signal) {
  [03:00:25.509]                     muffleCondition <- function (cond) 
  [03:00:25.509]                     {
  [03:00:25.509]                       inherits <- base::inherits
  [03:00:25.509]                       invokeRestart <- base::invokeRestart
  [03:00:25.509]                       muffled <- FALSE
  [03:00:25.509]                       if (inherits(cond, "message")) {
  [03:00:25.509]                         invokeRestart("muffleMessage")
  [03:00:25.509]                         muffled <- TRUE
  [03:00:25.509]                       }
  [03:00:25.509]                       else if (inherits(cond, "warning")) {
  [03:00:25.509]                         invokeRestart("muffleWarning")
  [03:00:25.509]                         muffled <- TRUE
  [03:00:25.509]                       }
  [03:00:25.509]                       else if (inherits(cond, "condition")) {
  [03:00:25.509]                         computeRestarts <- base::computeRestarts
  [03:00:25.509]                         grepl <- base::grepl
  [03:00:25.509]                         is.null <- base::is.null
  [03:00:25.509]                         restarts <- computeRestarts(cond)
  [03:00:25.509]                         for (restart in restarts) {
  [03:00:25.509]                           name <- restart$name
  [03:00:25.509]                           if (is.null(name)) 
  [03:00:25.509]                             next
  [03:00:25.509]                           if (!grepl("^muffle", name)) 
  [03:00:25.509]                             next
  [03:00:25.509]                           invokeRestart(restart)
  [03:00:25.509]                           muffled <- TRUE
  [03:00:25.509]                           break
  [03:00:25.509]                         }
  [03:00:25.509]                       }
  [03:00:25.509]                       invisible(muffled)
  [03:00:25.509]                     }
  [03:00:25.509]                     muffleCondition(cond)
  [03:00:25.509]                   }
  [03:00:25.509]                 }
  [03:00:25.509]             }
  [03:00:25.509]         }))
  [03:00:25.509]     }, error = function(ex) {
  [03:00:25.509]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.509]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.509]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.509]     }, finally = {
  [03:00:25.509]         {
  [03:00:25.509]             NULL
  [03:00:25.509]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.509]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.509]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.509]                 label = NULL, ...) 
  [03:00:25.509]             {
  [03:00:25.509]                 if (substitute) 
  [03:00:25.509]                   expr <- substitute(expr)
  [03:00:25.509]                 local <- as.logical(local)
  [03:00:25.509]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.509]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.509]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.509]                   label = label, ...)
  [03:00:25.509]                 if (!future$lazy) 
  [03:00:25.509]                   future <- run(future)
  [03:00:25.509]                 invisible(future)
  [03:00:25.509]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.509]         }
  [03:00:25.509]         base::options(...future.oldOptions)
  [03:00:25.509]     })
  [03:00:25.509]     Sys.time
  [03:00:25.509]     if (base::is.na(NA)) {
  [03:00:25.509]     }
  [03:00:25.509]     else {
  [03:00:25.509]         base::sink(type = "output", split = FALSE)
  [03:00:25.509]         if (NA) {
  [03:00:25.509]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.509]         }
  [03:00:25.509]         else {
  [03:00:25.509]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.509]         }
  [03:00:25.509]         base::close(...future.stdout)
  [03:00:25.509]         ...future.stdout <- NULL
  [03:00:25.509]     }
  [03:00:25.509]     ...future.result$conditions <- ...future.conditions
  [03:00:25.509]     ...future.result
  [03:00:25.509] }
  [03:00:25.519] plan(): Setting new future strategy stack:
  [03:00:25.522] List of future strategies:
  [03:00:25.522] 1. sequential:
  [03:00:25.522]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.522]    - tweaked: FALSE
  [03:00:25.522]    - call: NULL
  [03:00:25.525] plan(): nbrOfWorkers() = 1
  [03:00:25.532] Packages needed by the future expression (n = 0): <none>
  [03:00:25.535] Packages needed by future strategies (n = 0): <none>
  [03:00:25.544] {
  [03:00:25.544]     {
  [03:00:25.544]         ...future.startTime <- base::Sys.time()
  [03:00:25.544]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.544]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.544]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.544]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.544]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.544]         {
  [03:00:25.544]             {
  [03:00:25.544]                 base::local({
  [03:00:25.544]                   has_future <- base::requireNamespace("future", 
  [03:00:25.544]                     quietly = TRUE)
  [03:00:25.544]                   version <- if (has_future) 
  [03:00:25.544]                     utils::packageVersion("future")
  [03:00:25.544]                   else NULL
  [03:00:25.544]                   if (!has_future || version < "1.8.0") {
  [03:00:25.544]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.544]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.544]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.544]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.544]                         "release", "version")], collapse = " "), 
  [03:00:25.544]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.544]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.544]                       info)
  [03:00:25.544]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.544]                     if (!has_future) {
  [03:00:25.544]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.544]                         info)
  [03:00:25.544]                     }
  [03:00:25.544]                     else {
  [03:00:25.544]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.544]                         info, version)
  [03:00:25.544]                     }
  [03:00:25.544]                     base::stop(msg)
  [03:00:25.544]                   }
  [03:00:25.544]                 })
  [03:00:25.544]             }
  [03:00:25.544]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.544]         }
  [03:00:25.544]     }
  [03:00:25.544]     if (base::is.na(NA)) {
  [03:00:25.544]     }
  [03:00:25.544]     else {
  [03:00:25.544]         if (NA) {
  [03:00:25.544]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.544]                 open = "w")
  [03:00:25.544]         }
  [03:00:25.544]         else {
  [03:00:25.544]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.544]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.544]         }
  [03:00:25.544]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.544]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.544]             base::sink(type = "output", split = FALSE)
  [03:00:25.544]             base::close(...future.stdout)
  [03:00:25.544]         }, add = TRUE)
  [03:00:25.544]     }
  [03:00:25.544]     ...future.frame <- base::sys.nframe()
  [03:00:25.544]     ...future.conditions <- base::list()
  [03:00:25.544]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.544]     ...future.result <- base::tryCatch({
  [03:00:25.544]         base::withCallingHandlers({
  [03:00:25.544]             ...future.value <- base::withVisible(base::local({
  [03:00:25.544]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.544]             }))
  [03:00:25.544]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.544]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.544]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.544]                 version = "1.8")
  [03:00:25.544]         }, condition = base::local({
  [03:00:25.544]             c <- base::c
  [03:00:25.544]             inherits <- base::inherits
  [03:00:25.544]             invokeRestart <- base::invokeRestart
  [03:00:25.544]             length <- base::length
  [03:00:25.544]             list <- base::list
  [03:00:25.544]             seq.int <- base::seq.int
  [03:00:25.544]             signalCondition <- base::signalCondition
  [03:00:25.544]             sys.calls <- base::sys.calls
  [03:00:25.544]             Sys.time <- base::Sys.time
  [03:00:25.544]             `[[` <- base::`[[`
  [03:00:25.544]             `+` <- base::`+`
  [03:00:25.544]             `<<-` <- base::`<<-`
  [03:00:25.544]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.544]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.544]                   3L)]
  [03:00:25.544]             }
  [03:00:25.544]             function(cond) {
  [03:00:25.544]                 if (inherits(cond, "error")) {
  [03:00:25.544]                   sessionInformation <- function() {
  [03:00:25.544]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.544]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.544]                       search = base::search(), system = base::Sys.info())
  [03:00:25.544]                   }
  [03:00:25.544]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.544]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.544]                     cond$call), session = sessionInformation(), 
  [03:00:25.544]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.544]                   signalCondition(cond)
  [03:00:25.544]                 }
  [03:00:25.544]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.544]                 ))) {
  [03:00:25.544]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.544]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.544]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.544]                   if (!signal) {
  [03:00:25.544]                     muffleCondition <- function (cond) 
  [03:00:25.544]                     {
  [03:00:25.544]                       inherits <- base::inherits
  [03:00:25.544]                       invokeRestart <- base::invokeRestart
  [03:00:25.544]                       muffled <- FALSE
  [03:00:25.544]                       if (inherits(cond, "message")) {
  [03:00:25.544]                         invokeRestart("muffleMessage")
  [03:00:25.544]                         muffled <- TRUE
  [03:00:25.544]                       }
  [03:00:25.544]                       else if (inherits(cond, "warning")) {
  [03:00:25.544]                         invokeRestart("muffleWarning")
  [03:00:25.544]                         muffled <- TRUE
  [03:00:25.544]                       }
  [03:00:25.544]                       else if (inherits(cond, "condition")) {
  [03:00:25.544]                         computeRestarts <- base::computeRestarts
  [03:00:25.544]                         grepl <- base::grepl
  [03:00:25.544]                         is.null <- base::is.null
  [03:00:25.544]                         restarts <- computeRestarts(cond)
  [03:00:25.544]                         for (restart in restarts) {
  [03:00:25.544]                           name <- restart$name
  [03:00:25.544]                           if (is.null(name)) 
  [03:00:25.544]                             next
  [03:00:25.544]                           if (!grepl("^muffle", name)) 
  [03:00:25.544]                             next
  [03:00:25.544]                           invokeRestart(restart)
  [03:00:25.544]                           muffled <- TRUE
  [03:00:25.544]                           break
  [03:00:25.544]                         }
  [03:00:25.544]                       }
  [03:00:25.544]                       invisible(muffled)
  [03:00:25.544]                     }
  [03:00:25.544]                     muffleCondition(cond)
  [03:00:25.544]                   }
  [03:00:25.544]                 }
  [03:00:25.544]             }
  [03:00:25.544]         }))
  [03:00:25.544]     }, error = function(ex) {
  [03:00:25.544]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.544]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.544]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.544]     }, finally = {
  [03:00:25.544]         {
  [03:00:25.544]             NULL
  [03:00:25.544]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.544]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.544]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.544]                 label = NULL, ...) 
  [03:00:25.544]             {
  [03:00:25.544]                 if (substitute) 
  [03:00:25.544]                   expr <- substitute(expr)
  [03:00:25.544]                 local <- as.logical(local)
  [03:00:25.544]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.544]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.544]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.544]                   label = label, ...)
  [03:00:25.544]                 if (!future$lazy) 
  [03:00:25.544]                   future <- run(future)
  [03:00:25.544]                 invisible(future)
  [03:00:25.544]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.544]         }
  [03:00:25.544]         base::options(...future.oldOptions)
  [03:00:25.544]     })
  [03:00:25.544]     Sys.time
  [03:00:25.544]     if (base::is.na(NA)) {
  [03:00:25.544]     }
  [03:00:25.544]     else {
  [03:00:25.544]         base::sink(type = "output", split = FALSE)
  [03:00:25.544]         if (NA) {
  [03:00:25.544]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.544]         }
  [03:00:25.544]         else {
  [03:00:25.544]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.544]         }
  [03:00:25.544]         base::close(...future.stdout)
  [03:00:25.544]         ...future.stdout <- NULL
  [03:00:25.544]     }
  [03:00:25.544]     ...future.result$conditions <- ...future.conditions
  [03:00:25.544]     ...future.result
  [03:00:25.544] }
  [03:00:25.554] plan(): Setting new future strategy stack:
  [03:00:25.557] List of future strategies:
  [03:00:25.557] 1. sequential:
  [03:00:25.557]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.557]    - tweaked: FALSE
  [03:00:25.557]    - call: NULL
  [03:00:25.561] plan(): nbrOfWorkers() = 1
  [03:00:25.567] Packages needed by the future expression (n = 0): <none>
  [03:00:25.570] Packages needed by future strategies (n = 0): <none>
  [03:00:25.580] {
  [03:00:25.580]     {
  [03:00:25.580]         ...future.startTime <- base::Sys.time()
  [03:00:25.580]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.580]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.580]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.580]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.580]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.580]         {
  [03:00:25.580]             {
  [03:00:25.580]                 base::local({
  [03:00:25.580]                   has_future <- base::requireNamespace("future", 
  [03:00:25.580]                     quietly = TRUE)
  [03:00:25.580]                   version <- if (has_future) 
  [03:00:25.580]                     utils::packageVersion("future")
  [03:00:25.580]                   else NULL
  [03:00:25.580]                   if (!has_future || version < "1.8.0") {
  [03:00:25.580]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.580]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.580]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.580]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.580]                         "release", "version")], collapse = " "), 
  [03:00:25.580]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.580]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.580]                       info)
  [03:00:25.580]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.580]                     if (!has_future) {
  [03:00:25.580]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.580]                         info)
  [03:00:25.580]                     }
  [03:00:25.580]                     else {
  [03:00:25.580]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.580]                         info, version)
  [03:00:25.580]                     }
  [03:00:25.580]                     base::stop(msg)
  [03:00:25.580]                   }
  [03:00:25.580]                 })
  [03:00:25.580]             }
  [03:00:25.580]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.580]         }
  [03:00:25.580]     }
  [03:00:25.580]     if (base::is.na(NA)) {
  [03:00:25.580]     }
  [03:00:25.580]     else {
  [03:00:25.580]         if (NA) {
  [03:00:25.580]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.580]                 open = "w")
  [03:00:25.580]         }
  [03:00:25.580]         else {
  [03:00:25.580]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.580]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.580]         }
  [03:00:25.580]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.580]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.580]             base::sink(type = "output", split = FALSE)
  [03:00:25.580]             base::close(...future.stdout)
  [03:00:25.580]         }, add = TRUE)
  [03:00:25.580]     }
  [03:00:25.580]     ...future.frame <- base::sys.nframe()
  [03:00:25.580]     ...future.conditions <- base::list()
  [03:00:25.580]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.580]     ...future.result <- base::tryCatch({
  [03:00:25.580]         base::withCallingHandlers({
  [03:00:25.580]             ...future.value <- base::withVisible(base::local({
  [03:00:25.580]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.580]             }))
  [03:00:25.580]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.580]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.580]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.580]                 version = "1.8")
  [03:00:25.580]         }, condition = base::local({
  [03:00:25.580]             c <- base::c
  [03:00:25.580]             inherits <- base::inherits
  [03:00:25.580]             invokeRestart <- base::invokeRestart
  [03:00:25.580]             length <- base::length
  [03:00:25.580]             list <- base::list
  [03:00:25.580]             seq.int <- base::seq.int
  [03:00:25.580]             signalCondition <- base::signalCondition
  [03:00:25.580]             sys.calls <- base::sys.calls
  [03:00:25.580]             Sys.time <- base::Sys.time
  [03:00:25.580]             `[[` <- base::`[[`
  [03:00:25.580]             `+` <- base::`+`
  [03:00:25.580]             `<<-` <- base::`<<-`
  [03:00:25.580]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.580]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.580]                   3L)]
  [03:00:25.580]             }
  [03:00:25.580]             function(cond) {
  [03:00:25.580]                 if (inherits(cond, "error")) {
  [03:00:25.580]                   sessionInformation <- function() {
  [03:00:25.580]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.580]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.580]                       search = base::search(), system = base::Sys.info())
  [03:00:25.580]                   }
  [03:00:25.580]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.580]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.580]                     cond$call), session = sessionInformation(), 
  [03:00:25.580]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.580]                   signalCondition(cond)
  [03:00:25.580]                 }
  [03:00:25.580]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.580]                 ))) {
  [03:00:25.580]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.580]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.580]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.580]                   if (!signal) {
  [03:00:25.580]                     muffleCondition <- function (cond) 
  [03:00:25.580]                     {
  [03:00:25.580]                       inherits <- base::inherits
  [03:00:25.580]                       invokeRestart <- base::invokeRestart
  [03:00:25.580]                       muffled <- FALSE
  [03:00:25.580]                       if (inherits(cond, "message")) {
  [03:00:25.580]                         invokeRestart("muffleMessage")
  [03:00:25.580]                         muffled <- TRUE
  [03:00:25.580]                       }
  [03:00:25.580]                       else if (inherits(cond, "warning")) {
  [03:00:25.580]                         invokeRestart("muffleWarning")
  [03:00:25.580]                         muffled <- TRUE
  [03:00:25.580]                       }
  [03:00:25.580]                       else if (inherits(cond, "condition")) {
  [03:00:25.580]                         computeRestarts <- base::computeRestarts
  [03:00:25.580]                         grepl <- base::grepl
  [03:00:25.580]                         is.null <- base::is.null
  [03:00:25.580]                         restarts <- computeRestarts(cond)
  [03:00:25.580]                         for (restart in restarts) {
  [03:00:25.580]                           name <- restart$name
  [03:00:25.580]                           if (is.null(name)) 
  [03:00:25.580]                             next
  [03:00:25.580]                           if (!grepl("^muffle", name)) 
  [03:00:25.580]                             next
  [03:00:25.580]                           invokeRestart(restart)
  [03:00:25.580]                           muffled <- TRUE
  [03:00:25.580]                           break
  [03:00:25.580]                         }
  [03:00:25.580]                       }
  [03:00:25.580]                       invisible(muffled)
  [03:00:25.580]                     }
  [03:00:25.580]                     muffleCondition(cond)
  [03:00:25.580]                   }
  [03:00:25.580]                 }
  [03:00:25.580]             }
  [03:00:25.580]         }))
  [03:00:25.580]     }, error = function(ex) {
  [03:00:25.580]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.580]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.580]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.580]     }, finally = {
  [03:00:25.580]         {
  [03:00:25.580]             NULL
  [03:00:25.580]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.580]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.580]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.580]                 label = NULL, ...) 
  [03:00:25.580]             {
  [03:00:25.580]                 if (substitute) 
  [03:00:25.580]                   expr <- substitute(expr)
  [03:00:25.580]                 local <- as.logical(local)
  [03:00:25.580]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.580]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.580]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.580]                   label = label, ...)
  [03:00:25.580]                 if (!future$lazy) 
  [03:00:25.580]                   future <- run(future)
  [03:00:25.580]                 invisible(future)
  [03:00:25.580]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.580]         }
  [03:00:25.580]         base::options(...future.oldOptions)
  [03:00:25.580]     })
  [03:00:25.580]     Sys.time
  [03:00:25.580]     if (base::is.na(NA)) {
  [03:00:25.580]     }
  [03:00:25.580]     else {
  [03:00:25.580]         base::sink(type = "output", split = FALSE)
  [03:00:25.580]         if (NA) {
  [03:00:25.580]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.580]         }
  [03:00:25.580]         else {
  [03:00:25.580]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.580]         }
  [03:00:25.580]         base::close(...future.stdout)
  [03:00:25.580]         ...future.stdout <- NULL
  [03:00:25.580]     }
  [03:00:25.580]     ...future.result$conditions <- ...future.conditions
  [03:00:25.580]     ...future.result
  [03:00:25.580] }
  [03:00:25.590] plan(): Setting new future strategy stack:
  [03:00:25.593] List of future strategies:
  [03:00:25.593] 1. sequential:
  [03:00:25.593]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.593]    - tweaked: FALSE
  [03:00:25.593]    - call: NULL
  [03:00:25.597] plan(): nbrOfWorkers() = 1
  [03:00:25.607] Packages needed by the future expression (n = 0): <none>
  [03:00:25.610] Packages needed by future strategies (n = 0): <none>
  [03:00:25.621] {
  [03:00:25.621]     {
  [03:00:25.621]         ...future.startTime <- base::Sys.time()
  [03:00:25.621]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.621]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.621]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.621]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.621]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.621]         {
  [03:00:25.621]             {
  [03:00:25.621]                 base::local({
  [03:00:25.621]                   has_future <- base::requireNamespace("future", 
  [03:00:25.621]                     quietly = TRUE)
  [03:00:25.621]                   version <- if (has_future) 
  [03:00:25.621]                     utils::packageVersion("future")
  [03:00:25.621]                   else NULL
  [03:00:25.621]                   if (!has_future || version < "1.8.0") {
  [03:00:25.621]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.621]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.621]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.621]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.621]                         "release", "version")], collapse = " "), 
  [03:00:25.621]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.621]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.621]                       info)
  [03:00:25.621]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.621]                     if (!has_future) {
  [03:00:25.621]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.621]                         info)
  [03:00:25.621]                     }
  [03:00:25.621]                     else {
  [03:00:25.621]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.621]                         info, version)
  [03:00:25.621]                     }
  [03:00:25.621]                     base::stop(msg)
  [03:00:25.621]                   }
  [03:00:25.621]                 })
  [03:00:25.621]             }
  [03:00:25.621]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.621]         }
  [03:00:25.621]     }
  [03:00:25.621]     if (base::is.na(NA)) {
  [03:00:25.621]     }
  [03:00:25.621]     else {
  [03:00:25.621]         if (NA) {
  [03:00:25.621]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.621]                 open = "w")
  [03:00:25.621]         }
  [03:00:25.621]         else {
  [03:00:25.621]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.621]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.621]         }
  [03:00:25.621]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.621]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.621]             base::sink(type = "output", split = FALSE)
  [03:00:25.621]             base::close(...future.stdout)
  [03:00:25.621]         }, add = TRUE)
  [03:00:25.621]     }
  [03:00:25.621]     ...future.frame <- base::sys.nframe()
  [03:00:25.621]     ...future.conditions <- base::list()
  [03:00:25.621]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.621]     ...future.result <- base::tryCatch({
  [03:00:25.621]         base::withCallingHandlers({
  [03:00:25.621]             ...future.value <- base::withVisible(base::local({
  [03:00:25.621]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.621]             }))
  [03:00:25.621]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.621]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.621]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.621]                 version = "1.8")
  [03:00:25.621]         }, condition = base::local({
  [03:00:25.621]             c <- base::c
  [03:00:25.621]             inherits <- base::inherits
  [03:00:25.621]             invokeRestart <- base::invokeRestart
  [03:00:25.621]             length <- base::length
  [03:00:25.621]             list <- base::list
  [03:00:25.621]             seq.int <- base::seq.int
  [03:00:25.621]             signalCondition <- base::signalCondition
  [03:00:25.621]             sys.calls <- base::sys.calls
  [03:00:25.621]             Sys.time <- base::Sys.time
  [03:00:25.621]             `[[` <- base::`[[`
  [03:00:25.621]             `+` <- base::`+`
  [03:00:25.621]             `<<-` <- base::`<<-`
  [03:00:25.621]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.621]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.621]                   3L)]
  [03:00:25.621]             }
  [03:00:25.621]             function(cond) {
  [03:00:25.621]                 if (inherits(cond, "error")) {
  [03:00:25.621]                   sessionInformation <- function() {
  [03:00:25.621]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.621]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.621]                       search = base::search(), system = base::Sys.info())
  [03:00:25.621]                   }
  [03:00:25.621]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.621]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.621]                     cond$call), session = sessionInformation(), 
  [03:00:25.621]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.621]                   signalCondition(cond)
  [03:00:25.621]                 }
  [03:00:25.621]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.621]                 ))) {
  [03:00:25.621]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.621]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.621]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.621]                   if (!signal) {
  [03:00:25.621]                     muffleCondition <- function (cond) 
  [03:00:25.621]                     {
  [03:00:25.621]                       inherits <- base::inherits
  [03:00:25.621]                       invokeRestart <- base::invokeRestart
  [03:00:25.621]                       muffled <- FALSE
  [03:00:25.621]                       if (inherits(cond, "message")) {
  [03:00:25.621]                         invokeRestart("muffleMessage")
  [03:00:25.621]                         muffled <- TRUE
  [03:00:25.621]                       }
  [03:00:25.621]                       else if (inherits(cond, "warning")) {
  [03:00:25.621]                         invokeRestart("muffleWarning")
  [03:00:25.621]                         muffled <- TRUE
  [03:00:25.621]                       }
  [03:00:25.621]                       else if (inherits(cond, "condition")) {
  [03:00:25.621]                         computeRestarts <- base::computeRestarts
  [03:00:25.621]                         grepl <- base::grepl
  [03:00:25.621]                         is.null <- base::is.null
  [03:00:25.621]                         restarts <- computeRestarts(cond)
  [03:00:25.621]                         for (restart in restarts) {
  [03:00:25.621]                           name <- restart$name
  [03:00:25.621]                           if (is.null(name)) 
  [03:00:25.621]                             next
  [03:00:25.621]                           if (!grepl("^muffle", name)) 
  [03:00:25.621]                             next
  [03:00:25.621]                           invokeRestart(restart)
  [03:00:25.621]                           muffled <- TRUE
  [03:00:25.621]                           break
  [03:00:25.621]                         }
  [03:00:25.621]                       }
  [03:00:25.621]                       invisible(muffled)
  [03:00:25.621]                     }
  [03:00:25.621]                     muffleCondition(cond)
  [03:00:25.621]                   }
  [03:00:25.621]                 }
  [03:00:25.621]             }
  [03:00:25.621]         }))
  [03:00:25.621]     }, error = function(ex) {
  [03:00:25.621]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.621]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.621]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.621]     }, finally = {
  [03:00:25.621]         {
  [03:00:25.621]             NULL
  [03:00:25.621]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.621]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.621]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.621]                 label = NULL, ...) 
  [03:00:25.621]             {
  [03:00:25.621]                 if (substitute) 
  [03:00:25.621]                   expr <- substitute(expr)
  [03:00:25.621]                 local <- as.logical(local)
  [03:00:25.621]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.621]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.621]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.621]                   label = label, ...)
  [03:00:25.621]                 if (!future$lazy) 
  [03:00:25.621]                   future <- run(future)
  [03:00:25.621]                 invisible(future)
  [03:00:25.621]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.621]         }
  [03:00:25.621]         base::options(...future.oldOptions)
  [03:00:25.621]     })
  [03:00:25.621]     Sys.time
  [03:00:25.621]     if (base::is.na(NA)) {
  [03:00:25.621]     }
  [03:00:25.621]     else {
  [03:00:25.621]         base::sink(type = "output", split = FALSE)
  [03:00:25.621]         if (NA) {
  [03:00:25.621]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.621]         }
  [03:00:25.621]         else {
  [03:00:25.621]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.621]         }
  [03:00:25.621]         base::close(...future.stdout)
  [03:00:25.621]         ...future.stdout <- NULL
  [03:00:25.621]     }
  [03:00:25.621]     ...future.result$conditions <- ...future.conditions
  [03:00:25.621]     ...future.result
  [03:00:25.621] }
  [03:00:25.630] plan(): Setting new future strategy stack:
  [03:00:25.634] List of future strategies:
  [03:00:25.634] 1. sequential:
  [03:00:25.634]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.634]    - tweaked: FALSE
  [03:00:25.634]    - call: NULL
  [03:00:25.638] plan(): nbrOfWorkers() = 1
  [03:00:25.644] Packages needed by the future expression (n = 0): <none>
  [03:00:25.647] Packages needed by future strategies (n = 0): <none>
  [03:00:25.657] {
  [03:00:25.657]     {
  [03:00:25.657]         ...future.startTime <- base::Sys.time()
  [03:00:25.657]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.657]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.657]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.657]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.657]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.657]         {
  [03:00:25.657]             {
  [03:00:25.657]                 base::local({
  [03:00:25.657]                   has_future <- base::requireNamespace("future", 
  [03:00:25.657]                     quietly = TRUE)
  [03:00:25.657]                   version <- if (has_future) 
  [03:00:25.657]                     utils::packageVersion("future")
  [03:00:25.657]                   else NULL
  [03:00:25.657]                   if (!has_future || version < "1.8.0") {
  [03:00:25.657]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.657]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.657]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.657]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.657]                         "release", "version")], collapse = " "), 
  [03:00:25.657]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.657]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.657]                       info)
  [03:00:25.657]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.657]                     if (!has_future) {
  [03:00:25.657]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.657]                         info)
  [03:00:25.657]                     }
  [03:00:25.657]                     else {
  [03:00:25.657]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.657]                         info, version)
  [03:00:25.657]                     }
  [03:00:25.657]                     base::stop(msg)
  [03:00:25.657]                   }
  [03:00:25.657]                 })
  [03:00:25.657]             }
  [03:00:25.657]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.657]         }
  [03:00:25.657]     }
  [03:00:25.657]     if (base::is.na(NA)) {
  [03:00:25.657]     }
  [03:00:25.657]     else {
  [03:00:25.657]         if (NA) {
  [03:00:25.657]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.657]                 open = "w")
  [03:00:25.657]         }
  [03:00:25.657]         else {
  [03:00:25.657]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.657]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.657]         }
  [03:00:25.657]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.657]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.657]             base::sink(type = "output", split = FALSE)
  [03:00:25.657]             base::close(...future.stdout)
  [03:00:25.657]         }, add = TRUE)
  [03:00:25.657]     }
  [03:00:25.657]     ...future.frame <- base::sys.nframe()
  [03:00:25.657]     ...future.conditions <- base::list()
  [03:00:25.657]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.657]     ...future.result <- base::tryCatch({
  [03:00:25.657]         base::withCallingHandlers({
  [03:00:25.657]             ...future.value <- base::withVisible(base::local({
  [03:00:25.657]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.657]             }))
  [03:00:25.657]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.657]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.657]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.657]                 version = "1.8")
  [03:00:25.657]         }, condition = base::local({
  [03:00:25.657]             c <- base::c
  [03:00:25.657]             inherits <- base::inherits
  [03:00:25.657]             invokeRestart <- base::invokeRestart
  [03:00:25.657]             length <- base::length
  [03:00:25.657]             list <- base::list
  [03:00:25.657]             seq.int <- base::seq.int
  [03:00:25.657]             signalCondition <- base::signalCondition
  [03:00:25.657]             sys.calls <- base::sys.calls
  [03:00:25.657]             Sys.time <- base::Sys.time
  [03:00:25.657]             `[[` <- base::`[[`
  [03:00:25.657]             `+` <- base::`+`
  [03:00:25.657]             `<<-` <- base::`<<-`
  [03:00:25.657]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.657]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.657]                   3L)]
  [03:00:25.657]             }
  [03:00:25.657]             function(cond) {
  [03:00:25.657]                 if (inherits(cond, "error")) {
  [03:00:25.657]                   sessionInformation <- function() {
  [03:00:25.657]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.657]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.657]                       search = base::search(), system = base::Sys.info())
  [03:00:25.657]                   }
  [03:00:25.657]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.657]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.657]                     cond$call), session = sessionInformation(), 
  [03:00:25.657]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.657]                   signalCondition(cond)
  [03:00:25.657]                 }
  [03:00:25.657]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.657]                 ))) {
  [03:00:25.657]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.657]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.657]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.657]                   if (!signal) {
  [03:00:25.657]                     muffleCondition <- function (cond) 
  [03:00:25.657]                     {
  [03:00:25.657]                       inherits <- base::inherits
  [03:00:25.657]                       invokeRestart <- base::invokeRestart
  [03:00:25.657]                       muffled <- FALSE
  [03:00:25.657]                       if (inherits(cond, "message")) {
  [03:00:25.657]                         invokeRestart("muffleMessage")
  [03:00:25.657]                         muffled <- TRUE
  [03:00:25.657]                       }
  [03:00:25.657]                       else if (inherits(cond, "warning")) {
  [03:00:25.657]                         invokeRestart("muffleWarning")
  [03:00:25.657]                         muffled <- TRUE
  [03:00:25.657]                       }
  [03:00:25.657]                       else if (inherits(cond, "condition")) {
  [03:00:25.657]                         computeRestarts <- base::computeRestarts
  [03:00:25.657]                         grepl <- base::grepl
  [03:00:25.657]                         is.null <- base::is.null
  [03:00:25.657]                         restarts <- computeRestarts(cond)
  [03:00:25.657]                         for (restart in restarts) {
  [03:00:25.657]                           name <- restart$name
  [03:00:25.657]                           if (is.null(name)) 
  [03:00:25.657]                             next
  [03:00:25.657]                           if (!grepl("^muffle", name)) 
  [03:00:25.657]                             next
  [03:00:25.657]                           invokeRestart(restart)
  [03:00:25.657]                           muffled <- TRUE
  [03:00:25.657]                           break
  [03:00:25.657]                         }
  [03:00:25.657]                       }
  [03:00:25.657]                       invisible(muffled)
  [03:00:25.657]                     }
  [03:00:25.657]                     muffleCondition(cond)
  [03:00:25.657]                   }
  [03:00:25.657]                 }
  [03:00:25.657]             }
  [03:00:25.657]         }))
  [03:00:25.657]     }, error = function(ex) {
  [03:00:25.657]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.657]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.657]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.657]     }, finally = {
  [03:00:25.657]         {
  [03:00:25.657]             NULL
  [03:00:25.657]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.657]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.657]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.657]                 label = NULL, ...) 
  [03:00:25.657]             {
  [03:00:25.657]                 if (substitute) 
  [03:00:25.657]                   expr <- substitute(expr)
  [03:00:25.657]                 local <- as.logical(local)
  [03:00:25.657]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.657]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.657]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.657]                   label = label, ...)
  [03:00:25.657]                 if (!future$lazy) 
  [03:00:25.657]                   future <- run(future)
  [03:00:25.657]                 invisible(future)
  [03:00:25.657]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.657]         }
  [03:00:25.657]         base::options(...future.oldOptions)
  [03:00:25.657]     })
  [03:00:25.657]     Sys.time
  [03:00:25.657]     if (base::is.na(NA)) {
  [03:00:25.657]     }
  [03:00:25.657]     else {
  [03:00:25.657]         base::sink(type = "output", split = FALSE)
  [03:00:25.657]         if (NA) {
  [03:00:25.657]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.657]         }
  [03:00:25.657]         else {
  [03:00:25.657]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.657]         }
  [03:00:25.657]         base::close(...future.stdout)
  [03:00:25.657]         ...future.stdout <- NULL
  [03:00:25.657]     }
  [03:00:25.657]     ...future.result$conditions <- ...future.conditions
  [03:00:25.657]     ...future.result
  [03:00:25.657] }
  [03:00:25.667] plan(): Setting new future strategy stack:
  [03:00:25.670] List of future strategies:
  [03:00:25.670] 1. sequential:
  [03:00:25.670]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.670]    - tweaked: FALSE
  [03:00:25.670]    - call: NULL
  [03:00:25.674] plan(): nbrOfWorkers() = 1
  [03:00:25.680] Packages needed by the future expression (n = 0): <none>
  [03:00:25.684] Packages needed by future strategies (n = 0): <none>
  [03:00:25.694] {
  [03:00:25.694]     {
  [03:00:25.694]         ...future.startTime <- base::Sys.time()
  [03:00:25.694]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.694]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.694]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.694]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.694]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.694]         {
  [03:00:25.694]             {
  [03:00:25.694]                 base::local({
  [03:00:25.694]                   has_future <- base::requireNamespace("future", 
  [03:00:25.694]                     quietly = TRUE)
  [03:00:25.694]                   version <- if (has_future) 
  [03:00:25.694]                     utils::packageVersion("future")
  [03:00:25.694]                   else NULL
  [03:00:25.694]                   if (!has_future || version < "1.8.0") {
  [03:00:25.694]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.694]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.694]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.694]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.694]                         "release", "version")], collapse = " "), 
  [03:00:25.694]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.694]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.694]                       info)
  [03:00:25.694]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.694]                     if (!has_future) {
  [03:00:25.694]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.694]                         info)
  [03:00:25.694]                     }
  [03:00:25.694]                     else {
  [03:00:25.694]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.694]                         info, version)
  [03:00:25.694]                     }
  [03:00:25.694]                     base::stop(msg)
  [03:00:25.694]                   }
  [03:00:25.694]                 })
  [03:00:25.694]             }
  [03:00:25.694]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.694]         }
  [03:00:25.694]     }
  [03:00:25.694]     if (base::is.na(NA)) {
  [03:00:25.694]     }
  [03:00:25.694]     else {
  [03:00:25.694]         if (NA) {
  [03:00:25.694]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.694]                 open = "w")
  [03:00:25.694]         }
  [03:00:25.694]         else {
  [03:00:25.694]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.694]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.694]         }
  [03:00:25.694]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.694]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.694]             base::sink(type = "output", split = FALSE)
  [03:00:25.694]             base::close(...future.stdout)
  [03:00:25.694]         }, add = TRUE)
  [03:00:25.694]     }
  [03:00:25.694]     ...future.frame <- base::sys.nframe()
  [03:00:25.694]     ...future.conditions <- base::list()
  [03:00:25.694]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.694]     ...future.result <- base::tryCatch({
  [03:00:25.694]         base::withCallingHandlers({
  [03:00:25.694]             ...future.value <- base::withVisible(base::local({
  [03:00:25.694]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.694]             }))
  [03:00:25.694]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.694]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.694]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.694]                 version = "1.8")
  [03:00:25.694]         }, condition = base::local({
  [03:00:25.694]             c <- base::c
  [03:00:25.694]             inherits <- base::inherits
  [03:00:25.694]             invokeRestart <- base::invokeRestart
  [03:00:25.694]             length <- base::length
  [03:00:25.694]             list <- base::list
  [03:00:25.694]             seq.int <- base::seq.int
  [03:00:25.694]             signalCondition <- base::signalCondition
  [03:00:25.694]             sys.calls <- base::sys.calls
  [03:00:25.694]             Sys.time <- base::Sys.time
  [03:00:25.694]             `[[` <- base::`[[`
  [03:00:25.694]             `+` <- base::`+`
  [03:00:25.694]             `<<-` <- base::`<<-`
  [03:00:25.694]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.694]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.694]                   3L)]
  [03:00:25.694]             }
  [03:00:25.694]             function(cond) {
  [03:00:25.694]                 if (inherits(cond, "error")) {
  [03:00:25.694]                   sessionInformation <- function() {
  [03:00:25.694]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.694]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.694]                       search = base::search(), system = base::Sys.info())
  [03:00:25.694]                   }
  [03:00:25.694]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.694]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.694]                     cond$call), session = sessionInformation(), 
  [03:00:25.694]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.694]                   signalCondition(cond)
  [03:00:25.694]                 }
  [03:00:25.694]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.694]                 ))) {
  [03:00:25.694]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.694]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.694]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.694]                   if (!signal) {
  [03:00:25.694]                     muffleCondition <- function (cond) 
  [03:00:25.694]                     {
  [03:00:25.694]                       inherits <- base::inherits
  [03:00:25.694]                       invokeRestart <- base::invokeRestart
  [03:00:25.694]                       muffled <- FALSE
  [03:00:25.694]                       if (inherits(cond, "message")) {
  [03:00:25.694]                         invokeRestart("muffleMessage")
  [03:00:25.694]                         muffled <- TRUE
  [03:00:25.694]                       }
  [03:00:25.694]                       else if (inherits(cond, "warning")) {
  [03:00:25.694]                         invokeRestart("muffleWarning")
  [03:00:25.694]                         muffled <- TRUE
  [03:00:25.694]                       }
  [03:00:25.694]                       else if (inherits(cond, "condition")) {
  [03:00:25.694]                         computeRestarts <- base::computeRestarts
  [03:00:25.694]                         grepl <- base::grepl
  [03:00:25.694]                         is.null <- base::is.null
  [03:00:25.694]                         restarts <- computeRestarts(cond)
  [03:00:25.694]                         for (restart in restarts) {
  [03:00:25.694]                           name <- restart$name
  [03:00:25.694]                           if (is.null(name)) 
  [03:00:25.694]                             next
  [03:00:25.694]                           if (!grepl("^muffle", name)) 
  [03:00:25.694]                             next
  [03:00:25.694]                           invokeRestart(restart)
  [03:00:25.694]                           muffled <- TRUE
  [03:00:25.694]                           break
  [03:00:25.694]                         }
  [03:00:25.694]                       }
  [03:00:25.694]                       invisible(muffled)
  [03:00:25.694]                     }
  [03:00:25.694]                     muffleCondition(cond)
  [03:00:25.694]                   }
  [03:00:25.694]                 }
  [03:00:25.694]             }
  [03:00:25.694]         }))
  [03:00:25.694]     }, error = function(ex) {
  [03:00:25.694]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.694]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.694]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.694]     }, finally = {
  [03:00:25.694]         {
  [03:00:25.694]             NULL
  [03:00:25.694]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.694]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.694]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.694]                 label = NULL, ...) 
  [03:00:25.694]             {
  [03:00:25.694]                 if (substitute) 
  [03:00:25.694]                   expr <- substitute(expr)
  [03:00:25.694]                 local <- as.logical(local)
  [03:00:25.694]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.694]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.694]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.694]                   label = label, ...)
  [03:00:25.694]                 if (!future$lazy) 
  [03:00:25.694]                   future <- run(future)
  [03:00:25.694]                 invisible(future)
  [03:00:25.694]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.694]         }
  [03:00:25.694]         base::options(...future.oldOptions)
  [03:00:25.694]     })
  [03:00:25.694]     Sys.time
  [03:00:25.694]     if (base::is.na(NA)) {
  [03:00:25.694]     }
  [03:00:25.694]     else {
  [03:00:25.694]         base::sink(type = "output", split = FALSE)
  [03:00:25.694]         if (NA) {
  [03:00:25.694]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.694]         }
  [03:00:25.694]         else {
  [03:00:25.694]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.694]         }
  [03:00:25.694]         base::close(...future.stdout)
  [03:00:25.694]         ...future.stdout <- NULL
  [03:00:25.694]     }
  [03:00:25.694]     ...future.result$conditions <- ...future.conditions
  [03:00:25.694]     ...future.result
  [03:00:25.694] }
  [03:00:25.705] plan(): Setting new future strategy stack:
  [03:00:25.708] List of future strategies:
  [03:00:25.708] 1. sequential:
  [03:00:25.708]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.708]    - tweaked: FALSE
  [03:00:25.708]    - call: NULL
  [03:00:25.713] plan(): nbrOfWorkers() = 1
  [03:00:25.719] Packages needed by the future expression (n = 0): <none>
  [03:00:25.723] Packages needed by future strategies (n = 0): <none>
  [03:00:25.733] {
  [03:00:25.733]     {
  [03:00:25.733]         ...future.startTime <- base::Sys.time()
  [03:00:25.733]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.733]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.733]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.733]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.733]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.733]         {
  [03:00:25.733]             {
  [03:00:25.733]                 base::local({
  [03:00:25.733]                   has_future <- base::requireNamespace("future", 
  [03:00:25.733]                     quietly = TRUE)
  [03:00:25.733]                   version <- if (has_future) 
  [03:00:25.733]                     utils::packageVersion("future")
  [03:00:25.733]                   else NULL
  [03:00:25.733]                   if (!has_future || version < "1.8.0") {
  [03:00:25.733]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.733]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.733]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.733]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.733]                         "release", "version")], collapse = " "), 
  [03:00:25.733]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.733]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.733]                       info)
  [03:00:25.733]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.733]                     if (!has_future) {
  [03:00:25.733]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.733]                         info)
  [03:00:25.733]                     }
  [03:00:25.733]                     else {
  [03:00:25.733]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.733]                         info, version)
  [03:00:25.733]                     }
  [03:00:25.733]                     base::stop(msg)
  [03:00:25.733]                   }
  [03:00:25.733]                 })
  [03:00:25.733]             }
  [03:00:25.733]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.733]         }
  [03:00:25.733]     }
  [03:00:25.733]     if (base::is.na(NA)) {
  [03:00:25.733]     }
  [03:00:25.733]     else {
  [03:00:25.733]         if (NA) {
  [03:00:25.733]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.733]                 open = "w")
  [03:00:25.733]         }
  [03:00:25.733]         else {
  [03:00:25.733]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.733]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.733]         }
  [03:00:25.733]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.733]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.733]             base::sink(type = "output", split = FALSE)
  [03:00:25.733]             base::close(...future.stdout)
  [03:00:25.733]         }, add = TRUE)
  [03:00:25.733]     }
  [03:00:25.733]     ...future.frame <- base::sys.nframe()
  [03:00:25.733]     ...future.conditions <- base::list()
  [03:00:25.733]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.733]     ...future.result <- base::tryCatch({
  [03:00:25.733]         base::withCallingHandlers({
  [03:00:25.733]             ...future.value <- base::withVisible(base::local({
  [03:00:25.733]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.733]             }))
  [03:00:25.733]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.733]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.733]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.733]                 version = "1.8")
  [03:00:25.733]         }, condition = base::local({
  [03:00:25.733]             c <- base::c
  [03:00:25.733]             inherits <- base::inherits
  [03:00:25.733]             invokeRestart <- base::invokeRestart
  [03:00:25.733]             length <- base::length
  [03:00:25.733]             list <- base::list
  [03:00:25.733]             seq.int <- base::seq.int
  [03:00:25.733]             signalCondition <- base::signalCondition
  [03:00:25.733]             sys.calls <- base::sys.calls
  [03:00:25.733]             Sys.time <- base::Sys.time
  [03:00:25.733]             `[[` <- base::`[[`
  [03:00:25.733]             `+` <- base::`+`
  [03:00:25.733]             `<<-` <- base::`<<-`
  [03:00:25.733]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.733]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.733]                   3L)]
  [03:00:25.733]             }
  [03:00:25.733]             function(cond) {
  [03:00:25.733]                 if (inherits(cond, "error")) {
  [03:00:25.733]                   sessionInformation <- function() {
  [03:00:25.733]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.733]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.733]                       search = base::search(), system = base::Sys.info())
  [03:00:25.733]                   }
  [03:00:25.733]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.733]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.733]                     cond$call), session = sessionInformation(), 
  [03:00:25.733]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.733]                   signalCondition(cond)
  [03:00:25.733]                 }
  [03:00:25.733]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.733]                 ))) {
  [03:00:25.733]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.733]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.733]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.733]                   if (!signal) {
  [03:00:25.733]                     muffleCondition <- function (cond) 
  [03:00:25.733]                     {
  [03:00:25.733]                       inherits <- base::inherits
  [03:00:25.733]                       invokeRestart <- base::invokeRestart
  [03:00:25.733]                       muffled <- FALSE
  [03:00:25.733]                       if (inherits(cond, "message")) {
  [03:00:25.733]                         invokeRestart("muffleMessage")
  [03:00:25.733]                         muffled <- TRUE
  [03:00:25.733]                       }
  [03:00:25.733]                       else if (inherits(cond, "warning")) {
  [03:00:25.733]                         invokeRestart("muffleWarning")
  [03:00:25.733]                         muffled <- TRUE
  [03:00:25.733]                       }
  [03:00:25.733]                       else if (inherits(cond, "condition")) {
  [03:00:25.733]                         computeRestarts <- base::computeRestarts
  [03:00:25.733]                         grepl <- base::grepl
  [03:00:25.733]                         is.null <- base::is.null
  [03:00:25.733]                         restarts <- computeRestarts(cond)
  [03:00:25.733]                         for (restart in restarts) {
  [03:00:25.733]                           name <- restart$name
  [03:00:25.733]                           if (is.null(name)) 
  [03:00:25.733]                             next
  [03:00:25.733]                           if (!grepl("^muffle", name)) 
  [03:00:25.733]                             next
  [03:00:25.733]                           invokeRestart(restart)
  [03:00:25.733]                           muffled <- TRUE
  [03:00:25.733]                           break
  [03:00:25.733]                         }
  [03:00:25.733]                       }
  [03:00:25.733]                       invisible(muffled)
  [03:00:25.733]                     }
  [03:00:25.733]                     muffleCondition(cond)
  [03:00:25.733]                   }
  [03:00:25.733]                 }
  [03:00:25.733]             }
  [03:00:25.733]         }))
  [03:00:25.733]     }, error = function(ex) {
  [03:00:25.733]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.733]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.733]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.733]     }, finally = {
  [03:00:25.733]         {
  [03:00:25.733]             NULL
  [03:00:25.733]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.733]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.733]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.733]                 label = NULL, ...) 
  [03:00:25.733]             {
  [03:00:25.733]                 if (substitute) 
  [03:00:25.733]                   expr <- substitute(expr)
  [03:00:25.733]                 local <- as.logical(local)
  [03:00:25.733]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.733]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.733]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.733]                   label = label, ...)
  [03:00:25.733]                 if (!future$lazy) 
  [03:00:25.733]                   future <- run(future)
  [03:00:25.733]                 invisible(future)
  [03:00:25.733]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.733]         }
  [03:00:25.733]         base::options(...future.oldOptions)
  [03:00:25.733]     })
  [03:00:25.733]     Sys.time
  [03:00:25.733]     if (base::is.na(NA)) {
  [03:00:25.733]     }
  [03:00:25.733]     else {
  [03:00:25.733]         base::sink(type = "output", split = FALSE)
  [03:00:25.733]         if (NA) {
  [03:00:25.733]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.733]         }
  [03:00:25.733]         else {
  [03:00:25.733]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.733]         }
  [03:00:25.733]         base::close(...future.stdout)
  [03:00:25.733]         ...future.stdout <- NULL
  [03:00:25.733]     }
  [03:00:25.733]     ...future.result$conditions <- ...future.conditions
  [03:00:25.733]     ...future.result
  [03:00:25.733] }
  [03:00:25.744] plan(): Setting new future strategy stack:
  [03:00:25.747] List of future strategies:
  [03:00:25.747] 1. sequential:
  [03:00:25.747]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.747]    - tweaked: FALSE
  [03:00:25.747]    - call: NULL
  [03:00:25.757] plan(): nbrOfWorkers() = 1
  [03:00:25.764] Packages needed by the future expression (n = 0): <none>
  [03:00:25.768] Packages needed by future strategies (n = 0): <none>
  [03:00:25.779] {
  [03:00:25.779]     {
  [03:00:25.779]         ...future.startTime <- base::Sys.time()
  [03:00:25.779]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.779]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.779]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.779]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.779]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.779]         {
  [03:00:25.779]             {
  [03:00:25.779]                 base::local({
  [03:00:25.779]                   has_future <- base::requireNamespace("future", 
  [03:00:25.779]                     quietly = TRUE)
  [03:00:25.779]                   version <- if (has_future) 
  [03:00:25.779]                     utils::packageVersion("future")
  [03:00:25.779]                   else NULL
  [03:00:25.779]                   if (!has_future || version < "1.8.0") {
  [03:00:25.779]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.779]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.779]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.779]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.779]                         "release", "version")], collapse = " "), 
  [03:00:25.779]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.779]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.779]                       info)
  [03:00:25.779]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.779]                     if (!has_future) {
  [03:00:25.779]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.779]                         info)
  [03:00:25.779]                     }
  [03:00:25.779]                     else {
  [03:00:25.779]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.779]                         info, version)
  [03:00:25.779]                     }
  [03:00:25.779]                     base::stop(msg)
  [03:00:25.779]                   }
  [03:00:25.779]                 })
  [03:00:25.779]             }
  [03:00:25.779]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.779]         }
  [03:00:25.779]     }
  [03:00:25.779]     if (base::is.na(NA)) {
  [03:00:25.779]     }
  [03:00:25.779]     else {
  [03:00:25.779]         if (NA) {
  [03:00:25.779]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.779]                 open = "w")
  [03:00:25.779]         }
  [03:00:25.779]         else {
  [03:00:25.779]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.779]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.779]         }
  [03:00:25.779]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.779]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.779]             base::sink(type = "output", split = FALSE)
  [03:00:25.779]             base::close(...future.stdout)
  [03:00:25.779]         }, add = TRUE)
  [03:00:25.779]     }
  [03:00:25.779]     ...future.frame <- base::sys.nframe()
  [03:00:25.779]     ...future.conditions <- base::list()
  [03:00:25.779]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.779]     ...future.result <- base::tryCatch({
  [03:00:25.779]         base::withCallingHandlers({
  [03:00:25.779]             ...future.value <- base::withVisible(base::local({
  [03:00:25.779]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.779]             }))
  [03:00:25.779]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.779]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.779]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.779]                 version = "1.8")
  [03:00:25.779]         }, condition = base::local({
  [03:00:25.779]             c <- base::c
  [03:00:25.779]             inherits <- base::inherits
  [03:00:25.779]             invokeRestart <- base::invokeRestart
  [03:00:25.779]             length <- base::length
  [03:00:25.779]             list <- base::list
  [03:00:25.779]             seq.int <- base::seq.int
  [03:00:25.779]             signalCondition <- base::signalCondition
  [03:00:25.779]             sys.calls <- base::sys.calls
  [03:00:25.779]             Sys.time <- base::Sys.time
  [03:00:25.779]             `[[` <- base::`[[`
  [03:00:25.779]             `+` <- base::`+`
  [03:00:25.779]             `<<-` <- base::`<<-`
  [03:00:25.779]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.779]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.779]                   3L)]
  [03:00:25.779]             }
  [03:00:25.779]             function(cond) {
  [03:00:25.779]                 if (inherits(cond, "error")) {
  [03:00:25.779]                   sessionInformation <- function() {
  [03:00:25.779]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.779]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.779]                       search = base::search(), system = base::Sys.info())
  [03:00:25.779]                   }
  [03:00:25.779]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.779]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.779]                     cond$call), session = sessionInformation(), 
  [03:00:25.779]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.779]                   signalCondition(cond)
  [03:00:25.779]                 }
  [03:00:25.779]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.779]                 ))) {
  [03:00:25.779]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.779]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.779]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.779]                   if (!signal) {
  [03:00:25.779]                     muffleCondition <- function (cond) 
  [03:00:25.779]                     {
  [03:00:25.779]                       inherits <- base::inherits
  [03:00:25.779]                       invokeRestart <- base::invokeRestart
  [03:00:25.779]                       muffled <- FALSE
  [03:00:25.779]                       if (inherits(cond, "message")) {
  [03:00:25.779]                         invokeRestart("muffleMessage")
  [03:00:25.779]                         muffled <- TRUE
  [03:00:25.779]                       }
  [03:00:25.779]                       else if (inherits(cond, "warning")) {
  [03:00:25.779]                         invokeRestart("muffleWarning")
  [03:00:25.779]                         muffled <- TRUE
  [03:00:25.779]                       }
  [03:00:25.779]                       else if (inherits(cond, "condition")) {
  [03:00:25.779]                         computeRestarts <- base::computeRestarts
  [03:00:25.779]                         grepl <- base::grepl
  [03:00:25.779]                         is.null <- base::is.null
  [03:00:25.779]                         restarts <- computeRestarts(cond)
  [03:00:25.779]                         for (restart in restarts) {
  [03:00:25.779]                           name <- restart$name
  [03:00:25.779]                           if (is.null(name)) 
  [03:00:25.779]                             next
  [03:00:25.779]                           if (!grepl("^muffle", name)) 
  [03:00:25.779]                             next
  [03:00:25.779]                           invokeRestart(restart)
  [03:00:25.779]                           muffled <- TRUE
  [03:00:25.779]                           break
  [03:00:25.779]                         }
  [03:00:25.779]                       }
  [03:00:25.779]                       invisible(muffled)
  [03:00:25.779]                     }
  [03:00:25.779]                     muffleCondition(cond)
  [03:00:25.779]                   }
  [03:00:25.779]                 }
  [03:00:25.779]             }
  [03:00:25.779]         }))
  [03:00:25.779]     }, error = function(ex) {
  [03:00:25.779]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.779]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.779]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.779]     }, finally = {
  [03:00:25.779]         {
  [03:00:25.779]             NULL
  [03:00:25.779]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.779]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.779]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.779]                 label = NULL, ...) 
  [03:00:25.779]             {
  [03:00:25.779]                 if (substitute) 
  [03:00:25.779]                   expr <- substitute(expr)
  [03:00:25.779]                 local <- as.logical(local)
  [03:00:25.779]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.779]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.779]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.779]                   label = label, ...)
  [03:00:25.779]                 if (!future$lazy) 
  [03:00:25.779]                   future <- run(future)
  [03:00:25.779]                 invisible(future)
  [03:00:25.779]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.779]         }
  [03:00:25.779]         base::options(...future.oldOptions)
  [03:00:25.779]     })
  [03:00:25.779]     Sys.time
  [03:00:25.779]     if (base::is.na(NA)) {
  [03:00:25.779]     }
  [03:00:25.779]     else {
  [03:00:25.779]         base::sink(type = "output", split = FALSE)
  [03:00:25.779]         if (NA) {
  [03:00:25.779]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.779]         }
  [03:00:25.779]         else {
  [03:00:25.779]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.779]         }
  [03:00:25.779]         base::close(...future.stdout)
  [03:00:25.779]         ...future.stdout <- NULL
  [03:00:25.779]     }
  [03:00:25.779]     ...future.result$conditions <- ...future.conditions
  [03:00:25.779]     ...future.result
  [03:00:25.779] }
  [03:00:25.803] plan(): Setting new future strategy stack:
  [03:00:25.807] List of future strategies:
  [03:00:25.807] 1. sequential:
  [03:00:25.807]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.807]    - tweaked: FALSE
  [03:00:25.807]    - call: NULL
  [03:00:25.812] plan(): nbrOfWorkers() = 1
  [03:00:25.829] plan(): Setting new future strategy stack:
  [03:00:25.833] List of future strategies:
  [03:00:25.833] 1. sequential:
  [03:00:25.833]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.833]    - tweaked: FALSE
  [03:00:25.833]    - call: NULL
  [03:00:25.838] plan(): nbrOfWorkers() = 1
  [03:00:25.855] SequentialFuture started (and completed)
  [03:00:25.862] Packages needed by the future expression (n = 0): <none>
  [03:00:25.866] Packages needed by future strategies (n = 0): <none>
  [03:00:25.876] {
  [03:00:25.876]     {
  [03:00:25.876]         ...future.startTime <- base::Sys.time()
  [03:00:25.876]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.876]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.876]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.876]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.876]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.876]         {
  [03:00:25.876]             {
  [03:00:25.876]                 base::local({
  [03:00:25.876]                   has_future <- base::requireNamespace("future", 
  [03:00:25.876]                     quietly = TRUE)
  [03:00:25.876]                   version <- if (has_future) 
  [03:00:25.876]                     utils::packageVersion("future")
  [03:00:25.876]                   else NULL
  [03:00:25.876]                   if (!has_future || version < "1.8.0") {
  [03:00:25.876]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.876]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.876]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.876]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.876]                         "release", "version")], collapse = " "), 
  [03:00:25.876]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.876]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.876]                       info)
  [03:00:25.876]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.876]                     if (!has_future) {
  [03:00:25.876]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.876]                         info)
  [03:00:25.876]                     }
  [03:00:25.876]                     else {
  [03:00:25.876]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.876]                         info, version)
  [03:00:25.876]                     }
  [03:00:25.876]                     base::stop(msg)
  [03:00:25.876]                   }
  [03:00:25.876]                 })
  [03:00:25.876]             }
  [03:00:25.876]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.876]         }
  [03:00:25.876]     }
  [03:00:25.876]     if (base::is.na(NA)) {
  [03:00:25.876]     }
  [03:00:25.876]     else {
  [03:00:25.876]         if (NA) {
  [03:00:25.876]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.876]                 open = "w")
  [03:00:25.876]         }
  [03:00:25.876]         else {
  [03:00:25.876]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.876]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.876]         }
  [03:00:25.876]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.876]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.876]             base::sink(type = "output", split = FALSE)
  [03:00:25.876]             base::close(...future.stdout)
  [03:00:25.876]         }, add = TRUE)
  [03:00:25.876]     }
  [03:00:25.876]     ...future.frame <- base::sys.nframe()
  [03:00:25.876]     ...future.conditions <- base::list()
  [03:00:25.876]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.876]     ...future.result <- base::tryCatch({
  [03:00:25.876]         base::withCallingHandlers({
  [03:00:25.876]             ...future.value <- base::withVisible(base::local({
  [03:00:25.876]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.876]             }))
  [03:00:25.876]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.876]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.876]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.876]                 version = "1.8")
  [03:00:25.876]         }, condition = base::local({
  [03:00:25.876]             c <- base::c
  [03:00:25.876]             inherits <- base::inherits
  [03:00:25.876]             invokeRestart <- base::invokeRestart
  [03:00:25.876]             length <- base::length
  [03:00:25.876]             list <- base::list
  [03:00:25.876]             seq.int <- base::seq.int
  [03:00:25.876]             signalCondition <- base::signalCondition
  [03:00:25.876]             sys.calls <- base::sys.calls
  [03:00:25.876]             Sys.time <- base::Sys.time
  [03:00:25.876]             `[[` <- base::`[[`
  [03:00:25.876]             `+` <- base::`+`
  [03:00:25.876]             `<<-` <- base::`<<-`
  [03:00:25.876]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.876]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.876]                   3L)]
  [03:00:25.876]             }
  [03:00:25.876]             function(cond) {
  [03:00:25.876]                 if (inherits(cond, "error")) {
  [03:00:25.876]                   sessionInformation <- function() {
  [03:00:25.876]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.876]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.876]                       search = base::search(), system = base::Sys.info())
  [03:00:25.876]                   }
  [03:00:25.876]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.876]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.876]                     cond$call), session = sessionInformation(), 
  [03:00:25.876]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.876]                   signalCondition(cond)
  [03:00:25.876]                 }
  [03:00:25.876]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.876]                 ))) {
  [03:00:25.876]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.876]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.876]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.876]                   if (!signal) {
  [03:00:25.876]                     muffleCondition <- function (cond) 
  [03:00:25.876]                     {
  [03:00:25.876]                       inherits <- base::inherits
  [03:00:25.876]                       invokeRestart <- base::invokeRestart
  [03:00:25.876]                       muffled <- FALSE
  [03:00:25.876]                       if (inherits(cond, "message")) {
  [03:00:25.876]                         invokeRestart("muffleMessage")
  [03:00:25.876]                         muffled <- TRUE
  [03:00:25.876]                       }
  [03:00:25.876]                       else if (inherits(cond, "warning")) {
  [03:00:25.876]                         invokeRestart("muffleWarning")
  [03:00:25.876]                         muffled <- TRUE
  [03:00:25.876]                       }
  [03:00:25.876]                       else if (inherits(cond, "condition")) {
  [03:00:25.876]                         computeRestarts <- base::computeRestarts
  [03:00:25.876]                         grepl <- base::grepl
  [03:00:25.876]                         is.null <- base::is.null
  [03:00:25.876]                         restarts <- computeRestarts(cond)
  [03:00:25.876]                         for (restart in restarts) {
  [03:00:25.876]                           name <- restart$name
  [03:00:25.876]                           if (is.null(name)) 
  [03:00:25.876]                             next
  [03:00:25.876]                           if (!grepl("^muffle", name)) 
  [03:00:25.876]                             next
  [03:00:25.876]                           invokeRestart(restart)
  [03:00:25.876]                           muffled <- TRUE
  [03:00:25.876]                           break
  [03:00:25.876]                         }
  [03:00:25.876]                       }
  [03:00:25.876]                       invisible(muffled)
  [03:00:25.876]                     }
  [03:00:25.876]                     muffleCondition(cond)
  [03:00:25.876]                   }
  [03:00:25.876]                 }
  [03:00:25.876]             }
  [03:00:25.876]         }))
  [03:00:25.876]     }, error = function(ex) {
  [03:00:25.876]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.876]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.876]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.876]     }, finally = {
  [03:00:25.876]         {
  [03:00:25.876]             NULL
  [03:00:25.876]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.876]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.876]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.876]                 label = NULL, ...) 
  [03:00:25.876]             {
  [03:00:25.876]                 if (substitute) 
  [03:00:25.876]                   expr <- substitute(expr)
  [03:00:25.876]                 local <- as.logical(local)
  [03:00:25.876]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.876]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.876]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.876]                   label = label, ...)
  [03:00:25.876]                 if (!future$lazy) 
  [03:00:25.876]                   future <- run(future)
  [03:00:25.876]                 invisible(future)
  [03:00:25.876]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.876]         }
  [03:00:25.876]         base::options(...future.oldOptions)
  [03:00:25.876]     })
  [03:00:25.876]     Sys.time
  [03:00:25.876]     if (base::is.na(NA)) {
  [03:00:25.876]     }
  [03:00:25.876]     else {
  [03:00:25.876]         base::sink(type = "output", split = FALSE)
  [03:00:25.876]         if (NA) {
  [03:00:25.876]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.876]         }
  [03:00:25.876]         else {
  [03:00:25.876]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.876]         }
  [03:00:25.876]         base::close(...future.stdout)
  [03:00:25.876]         ...future.stdout <- NULL
  [03:00:25.876]     }
  [03:00:25.876]     ...future.result$conditions <- ...future.conditions
  [03:00:25.876]     ...future.result
  [03:00:25.876] }
  [03:00:25.887] plan(): Setting new future strategy stack:
  [03:00:25.891] List of future strategies:
  [03:00:25.891] 1. sequential:
  [03:00:25.891]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.891]    - tweaked: FALSE
  [03:00:25.891]    - call: NULL
  [03:00:25.896] plan(): nbrOfWorkers() = 1
  [03:00:25.901] plan(): Setting new future strategy stack:
  [03:00:25.905] List of future strategies:
  [03:00:25.905] 1. sequential:
  [03:00:25.905]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.905]    - tweaked: FALSE
  [03:00:25.905]    - call: NULL
  [03:00:25.910] plan(): nbrOfWorkers() = 1
  [03:00:25.914] SequentialFuture started (and completed)
  [03:00:25.919] plan(): Setting new future strategy stack:
  [03:00:25.922] List of future strategies:
  [03:00:25.922] 1. sequential:
  [03:00:25.922]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.922]    - tweaked: FALSE
  [03:00:25.922]    - call: NULL
  [03:00:25.927] plan(): nbrOfWorkers() = 1
  [03:00:25.931] SequentialFuture started (and completed)
  [03:00:25.937] Packages needed by the future expression (n = 0): <none>
  [03:00:25.941] Packages needed by future strategies (n = 0): <none>
  [03:00:25.952] {
  [03:00:25.952]     {
  [03:00:25.952]         ...future.startTime <- base::Sys.time()
  [03:00:25.952]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:25.952]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:25.952]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:25.952]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:25.952]             future.resolve.recursive = NULL, width = 80L)
  [03:00:25.952]         {
  [03:00:25.952]             {
  [03:00:25.952]                 base::local({
  [03:00:25.952]                   has_future <- base::requireNamespace("future", 
  [03:00:25.952]                     quietly = TRUE)
  [03:00:25.952]                   version <- if (has_future) 
  [03:00:25.952]                     utils::packageVersion("future")
  [03:00:25.952]                   else NULL
  [03:00:25.952]                   if (!has_future || version < "1.8.0") {
  [03:00:25.952]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:25.952]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:25.952]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:25.952]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:25.952]                         "release", "version")], collapse = " "), 
  [03:00:25.952]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:25.952]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:25.952]                       info)
  [03:00:25.952]                     info <- base::paste(info, collapse = "; ")
  [03:00:25.952]                     if (!has_future) {
  [03:00:25.952]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:25.952]                         info)
  [03:00:25.952]                     }
  [03:00:25.952]                     else {
  [03:00:25.952]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:25.952]                         info, version)
  [03:00:25.952]                     }
  [03:00:25.952]                     base::stop(msg)
  [03:00:25.952]                   }
  [03:00:25.952]                 })
  [03:00:25.952]             }
  [03:00:25.952]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:25.952]         }
  [03:00:25.952]     }
  [03:00:25.952]     if (base::is.na(NA)) {
  [03:00:25.952]     }
  [03:00:25.952]     else {
  [03:00:25.952]         if (NA) {
  [03:00:25.952]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:25.952]                 open = "w")
  [03:00:25.952]         }
  [03:00:25.952]         else {
  [03:00:25.952]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:25.952]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:25.952]         }
  [03:00:25.952]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:25.952]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:25.952]             base::sink(type = "output", split = FALSE)
  [03:00:25.952]             base::close(...future.stdout)
  [03:00:25.952]         }, add = TRUE)
  [03:00:25.952]     }
  [03:00:25.952]     ...future.frame <- base::sys.nframe()
  [03:00:25.952]     ...future.conditions <- base::list()
  [03:00:25.952]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:25.952]     ...future.result <- base::tryCatch({
  [03:00:25.952]         base::withCallingHandlers({
  [03:00:25.952]             ...future.value <- base::withVisible(base::local({
  [03:00:25.952]                 x[[i - 2]] + x[[i - 1]]
  [03:00:25.952]             }))
  [03:00:25.952]             future::FutureResult(value = ...future.value$value, 
  [03:00:25.952]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.952]                   ...future.rng), started = ...future.startTime, 
  [03:00:25.952]                 version = "1.8")
  [03:00:25.952]         }, condition = base::local({
  [03:00:25.952]             c <- base::c
  [03:00:25.952]             inherits <- base::inherits
  [03:00:25.952]             invokeRestart <- base::invokeRestart
  [03:00:25.952]             length <- base::length
  [03:00:25.952]             list <- base::list
  [03:00:25.952]             seq.int <- base::seq.int
  [03:00:25.952]             signalCondition <- base::signalCondition
  [03:00:25.952]             sys.calls <- base::sys.calls
  [03:00:25.952]             Sys.time <- base::Sys.time
  [03:00:25.952]             `[[` <- base::`[[`
  [03:00:25.952]             `+` <- base::`+`
  [03:00:25.952]             `<<-` <- base::`<<-`
  [03:00:25.952]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:25.952]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:25.952]                   3L)]
  [03:00:25.952]             }
  [03:00:25.952]             function(cond) {
  [03:00:25.952]                 if (inherits(cond, "error")) {
  [03:00:25.952]                   sessionInformation <- function() {
  [03:00:25.952]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:25.952]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:25.952]                       search = base::search(), system = base::Sys.info())
  [03:00:25.952]                   }
  [03:00:25.952]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.952]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:25.952]                     cond$call), session = sessionInformation(), 
  [03:00:25.952]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:25.952]                   signalCondition(cond)
  [03:00:25.952]                 }
  [03:00:25.952]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:25.952]                 ))) {
  [03:00:25.952]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:25.952]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:25.952]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:25.952]                   if (!signal) {
  [03:00:25.952]                     muffleCondition <- function (cond) 
  [03:00:25.952]                     {
  [03:00:25.952]                       inherits <- base::inherits
  [03:00:25.952]                       invokeRestart <- base::invokeRestart
  [03:00:25.952]                       muffled <- FALSE
  [03:00:25.952]                       if (inherits(cond, "message")) {
  [03:00:25.952]                         invokeRestart("muffleMessage")
  [03:00:25.952]                         muffled <- TRUE
  [03:00:25.952]                       }
  [03:00:25.952]                       else if (inherits(cond, "warning")) {
  [03:00:25.952]                         invokeRestart("muffleWarning")
  [03:00:25.952]                         muffled <- TRUE
  [03:00:25.952]                       }
  [03:00:25.952]                       else if (inherits(cond, "condition")) {
  [03:00:25.952]                         computeRestarts <- base::computeRestarts
  [03:00:25.952]                         grepl <- base::grepl
  [03:00:25.952]                         is.null <- base::is.null
  [03:00:25.952]                         restarts <- computeRestarts(cond)
  [03:00:25.952]                         for (restart in restarts) {
  [03:00:25.952]                           name <- restart$name
  [03:00:25.952]                           if (is.null(name)) 
  [03:00:25.952]                             next
  [03:00:25.952]                           if (!grepl("^muffle", name)) 
  [03:00:25.952]                             next
  [03:00:25.952]                           invokeRestart(restart)
  [03:00:25.952]                           muffled <- TRUE
  [03:00:25.952]                           break
  [03:00:25.952]                         }
  [03:00:25.952]                       }
  [03:00:25.952]                       invisible(muffled)
  [03:00:25.952]                     }
  [03:00:25.952]                     muffleCondition(cond)
  [03:00:25.952]                   }
  [03:00:25.952]                 }
  [03:00:25.952]             }
  [03:00:25.952]         }))
  [03:00:25.952]     }, error = function(ex) {
  [03:00:25.952]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:25.952]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:25.952]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:25.952]     }, finally = {
  [03:00:25.952]         {
  [03:00:25.952]             NULL
  [03:00:25.952]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:25.952]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:25.952]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:25.952]                 label = NULL, ...) 
  [03:00:25.952]             {
  [03:00:25.952]                 if (substitute) 
  [03:00:25.952]                   expr <- substitute(expr)
  [03:00:25.952]                 local <- as.logical(local)
  [03:00:25.952]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:25.952]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:25.952]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:25.952]                   label = label, ...)
  [03:00:25.952]                 if (!future$lazy) 
  [03:00:25.952]                   future <- run(future)
  [03:00:25.952]                 invisible(future)
  [03:00:25.952]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:25.952]         }
  [03:00:25.952]         base::options(...future.oldOptions)
  [03:00:25.952]     })
  [03:00:25.952]     Sys.time
  [03:00:25.952]     if (base::is.na(NA)) {
  [03:00:25.952]     }
  [03:00:25.952]     else {
  [03:00:25.952]         base::sink(type = "output", split = FALSE)
  [03:00:25.952]         if (NA) {
  [03:00:25.952]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:25.952]         }
  [03:00:25.952]         else {
  [03:00:25.952]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:25.952]         }
  [03:00:25.952]         base::close(...future.stdout)
  [03:00:25.952]         ...future.stdout <- NULL
  [03:00:25.952]     }
  [03:00:25.952]     ...future.result$conditions <- ...future.conditions
  [03:00:25.952]     ...future.result
  [03:00:25.952] }
  [03:00:25.966] plan(): Setting new future strategy stack:
  [03:00:25.970] List of future strategies:
  [03:00:25.970] 1. sequential:
  [03:00:25.970]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.970]    - tweaked: FALSE
  [03:00:25.970]    - call: NULL
  [03:00:25.975] plan(): nbrOfWorkers() = 1
  [03:00:25.980] plan(): Setting new future strategy stack:
  [03:00:25.984] List of future strategies:
  [03:00:25.984] 1. sequential:
  [03:00:25.984]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:25.984]    - tweaked: FALSE
  [03:00:25.984]    - call: NULL
  [03:00:25.989] plan(): nbrOfWorkers() = 1
  [03:00:25.993] SequentialFuture started (and completed)
  [03:00:25.997] plan(): Setting new future strategy stack:
  [03:00:26.001] List of future strategies:
  [03:00:26.001] 1. sequential:
  [03:00:26.001]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.001]    - tweaked: FALSE
  [03:00:26.001]    - call: NULL
  [03:00:26.006] plan(): nbrOfWorkers() = 1
  [03:00:26.010] SequentialFuture started (and completed)
  [03:00:26.016] Packages needed by the future expression (n = 0): <none>
  [03:00:26.019] Packages needed by future strategies (n = 0): <none>
  [03:00:26.029] {
  [03:00:26.029]     {
  [03:00:26.029]         ...future.startTime <- base::Sys.time()
  [03:00:26.029]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.029]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.029]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.029]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.029]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.029]         {
  [03:00:26.029]             {
  [03:00:26.029]                 base::local({
  [03:00:26.029]                   has_future <- base::requireNamespace("future", 
  [03:00:26.029]                     quietly = TRUE)
  [03:00:26.029]                   version <- if (has_future) 
  [03:00:26.029]                     utils::packageVersion("future")
  [03:00:26.029]                   else NULL
  [03:00:26.029]                   if (!has_future || version < "1.8.0") {
  [03:00:26.029]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.029]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.029]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.029]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.029]                         "release", "version")], collapse = " "), 
  [03:00:26.029]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.029]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.029]                       info)
  [03:00:26.029]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.029]                     if (!has_future) {
  [03:00:26.029]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.029]                         info)
  [03:00:26.029]                     }
  [03:00:26.029]                     else {
  [03:00:26.029]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.029]                         info, version)
  [03:00:26.029]                     }
  [03:00:26.029]                     base::stop(msg)
  [03:00:26.029]                   }
  [03:00:26.029]                 })
  [03:00:26.029]             }
  [03:00:26.029]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.029]         }
  [03:00:26.029]     }
  [03:00:26.029]     if (base::is.na(NA)) {
  [03:00:26.029]     }
  [03:00:26.029]     else {
  [03:00:26.029]         if (NA) {
  [03:00:26.029]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.029]                 open = "w")
  [03:00:26.029]         }
  [03:00:26.029]         else {
  [03:00:26.029]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.029]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.029]         }
  [03:00:26.029]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.029]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.029]             base::sink(type = "output", split = FALSE)
  [03:00:26.029]             base::close(...future.stdout)
  [03:00:26.029]         }, add = TRUE)
  [03:00:26.029]     }
  [03:00:26.029]     ...future.frame <- base::sys.nframe()
  [03:00:26.029]     ...future.conditions <- base::list()
  [03:00:26.029]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.029]     ...future.result <- base::tryCatch({
  [03:00:26.029]         base::withCallingHandlers({
  [03:00:26.029]             ...future.value <- base::withVisible(base::local({
  [03:00:26.029]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.029]             }))
  [03:00:26.029]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.029]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.029]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.029]                 version = "1.8")
  [03:00:26.029]         }, condition = base::local({
  [03:00:26.029]             c <- base::c
  [03:00:26.029]             inherits <- base::inherits
  [03:00:26.029]             invokeRestart <- base::invokeRestart
  [03:00:26.029]             length <- base::length
  [03:00:26.029]             list <- base::list
  [03:00:26.029]             seq.int <- base::seq.int
  [03:00:26.029]             signalCondition <- base::signalCondition
  [03:00:26.029]             sys.calls <- base::sys.calls
  [03:00:26.029]             Sys.time <- base::Sys.time
  [03:00:26.029]             `[[` <- base::`[[`
  [03:00:26.029]             `+` <- base::`+`
  [03:00:26.029]             `<<-` <- base::`<<-`
  [03:00:26.029]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.029]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.029]                   3L)]
  [03:00:26.029]             }
  [03:00:26.029]             function(cond) {
  [03:00:26.029]                 if (inherits(cond, "error")) {
  [03:00:26.029]                   sessionInformation <- function() {
  [03:00:26.029]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.029]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.029]                       search = base::search(), system = base::Sys.info())
  [03:00:26.029]                   }
  [03:00:26.029]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.029]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.029]                     cond$call), session = sessionInformation(), 
  [03:00:26.029]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.029]                   signalCondition(cond)
  [03:00:26.029]                 }
  [03:00:26.029]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.029]                 ))) {
  [03:00:26.029]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.029]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.029]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.029]                   if (!signal) {
  [03:00:26.029]                     muffleCondition <- function (cond) 
  [03:00:26.029]                     {
  [03:00:26.029]                       inherits <- base::inherits
  [03:00:26.029]                       invokeRestart <- base::invokeRestart
  [03:00:26.029]                       muffled <- FALSE
  [03:00:26.029]                       if (inherits(cond, "message")) {
  [03:00:26.029]                         invokeRestart("muffleMessage")
  [03:00:26.029]                         muffled <- TRUE
  [03:00:26.029]                       }
  [03:00:26.029]                       else if (inherits(cond, "warning")) {
  [03:00:26.029]                         invokeRestart("muffleWarning")
  [03:00:26.029]                         muffled <- TRUE
  [03:00:26.029]                       }
  [03:00:26.029]                       else if (inherits(cond, "condition")) {
  [03:00:26.029]                         computeRestarts <- base::computeRestarts
  [03:00:26.029]                         grepl <- base::grepl
  [03:00:26.029]                         is.null <- base::is.null
  [03:00:26.029]                         restarts <- computeRestarts(cond)
  [03:00:26.029]                         for (restart in restarts) {
  [03:00:26.029]                           name <- restart$name
  [03:00:26.029]                           if (is.null(name)) 
  [03:00:26.029]                             next
  [03:00:26.029]                           if (!grepl("^muffle", name)) 
  [03:00:26.029]                             next
  [03:00:26.029]                           invokeRestart(restart)
  [03:00:26.029]                           muffled <- TRUE
  [03:00:26.029]                           break
  [03:00:26.029]                         }
  [03:00:26.029]                       }
  [03:00:26.029]                       invisible(muffled)
  [03:00:26.029]                     }
  [03:00:26.029]                     muffleCondition(cond)
  [03:00:26.029]                   }
  [03:00:26.029]                 }
  [03:00:26.029]             }
  [03:00:26.029]         }))
  [03:00:26.029]     }, error = function(ex) {
  [03:00:26.029]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.029]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.029]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.029]     }, finally = {
  [03:00:26.029]         {
  [03:00:26.029]             NULL
  [03:00:26.029]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.029]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.029]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.029]                 label = NULL, ...) 
  [03:00:26.029]             {
  [03:00:26.029]                 if (substitute) 
  [03:00:26.029]                   expr <- substitute(expr)
  [03:00:26.029]                 local <- as.logical(local)
  [03:00:26.029]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.029]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.029]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.029]                   label = label, ...)
  [03:00:26.029]                 if (!future$lazy) 
  [03:00:26.029]                   future <- run(future)
  [03:00:26.029]                 invisible(future)
  [03:00:26.029]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.029]         }
  [03:00:26.029]         base::options(...future.oldOptions)
  [03:00:26.029]     })
  [03:00:26.029]     Sys.time
  [03:00:26.029]     if (base::is.na(NA)) {
  [03:00:26.029]     }
  [03:00:26.029]     else {
  [03:00:26.029]         base::sink(type = "output", split = FALSE)
  [03:00:26.029]         if (NA) {
  [03:00:26.029]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.029]         }
  [03:00:26.029]         else {
  [03:00:26.029]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.029]         }
  [03:00:26.029]         base::close(...future.stdout)
  [03:00:26.029]         ...future.stdout <- NULL
  [03:00:26.029]     }
  [03:00:26.029]     ...future.result$conditions <- ...future.conditions
  [03:00:26.029]     ...future.result
  [03:00:26.029] }
  [03:00:26.040] plan(): Setting new future strategy stack:
  [03:00:26.043] List of future strategies:
  [03:00:26.043] 1. sequential:
  [03:00:26.043]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.043]    - tweaked: FALSE
  [03:00:26.043]    - call: NULL
  [03:00:26.048] plan(): nbrOfWorkers() = 1
  [03:00:26.053] plan(): Setting new future strategy stack:
  [03:00:26.056] List of future strategies:
  [03:00:26.056] 1. sequential:
  [03:00:26.056]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.056]    - tweaked: FALSE
  [03:00:26.056]    - call: NULL
  [03:00:26.061] plan(): nbrOfWorkers() = 1
  [03:00:26.064] SequentialFuture started (and completed)
  [03:00:26.069] plan(): Setting new future strategy stack:
  [03:00:26.072] List of future strategies:
  [03:00:26.072] 1. sequential:
  [03:00:26.072]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.072]    - tweaked: FALSE
  [03:00:26.072]    - call: NULL
  [03:00:26.076] plan(): nbrOfWorkers() = 1
  [03:00:26.080] SequentialFuture started (and completed)
  [03:00:26.088] Packages needed by the future expression (n = 0): <none>
  [03:00:26.092] Packages needed by future strategies (n = 0): <none>
  [03:00:26.101] {
  [03:00:26.101]     {
  [03:00:26.101]         ...future.startTime <- base::Sys.time()
  [03:00:26.101]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.101]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.101]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.101]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.101]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.101]         {
  [03:00:26.101]             {
  [03:00:26.101]                 base::local({
  [03:00:26.101]                   has_future <- base::requireNamespace("future", 
  [03:00:26.101]                     quietly = TRUE)
  [03:00:26.101]                   version <- if (has_future) 
  [03:00:26.101]                     utils::packageVersion("future")
  [03:00:26.101]                   else NULL
  [03:00:26.101]                   if (!has_future || version < "1.8.0") {
  [03:00:26.101]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.101]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.101]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.101]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.101]                         "release", "version")], collapse = " "), 
  [03:00:26.101]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.101]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.101]                       info)
  [03:00:26.101]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.101]                     if (!has_future) {
  [03:00:26.101]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.101]                         info)
  [03:00:26.101]                     }
  [03:00:26.101]                     else {
  [03:00:26.101]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.101]                         info, version)
  [03:00:26.101]                     }
  [03:00:26.101]                     base::stop(msg)
  [03:00:26.101]                   }
  [03:00:26.101]                 })
  [03:00:26.101]             }
  [03:00:26.101]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.101]         }
  [03:00:26.101]     }
  [03:00:26.101]     if (base::is.na(NA)) {
  [03:00:26.101]     }
  [03:00:26.101]     else {
  [03:00:26.101]         if (NA) {
  [03:00:26.101]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.101]                 open = "w")
  [03:00:26.101]         }
  [03:00:26.101]         else {
  [03:00:26.101]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.101]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.101]         }
  [03:00:26.101]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.101]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.101]             base::sink(type = "output", split = FALSE)
  [03:00:26.101]             base::close(...future.stdout)
  [03:00:26.101]         }, add = TRUE)
  [03:00:26.101]     }
  [03:00:26.101]     ...future.frame <- base::sys.nframe()
  [03:00:26.101]     ...future.conditions <- base::list()
  [03:00:26.101]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.101]     ...future.result <- base::tryCatch({
  [03:00:26.101]         base::withCallingHandlers({
  [03:00:26.101]             ...future.value <- base::withVisible(base::local({
  [03:00:26.101]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.101]             }))
  [03:00:26.101]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.101]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.101]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.101]                 version = "1.8")
  [03:00:26.101]         }, condition = base::local({
  [03:00:26.101]             c <- base::c
  [03:00:26.101]             inherits <- base::inherits
  [03:00:26.101]             invokeRestart <- base::invokeRestart
  [03:00:26.101]             length <- base::length
  [03:00:26.101]             list <- base::list
  [03:00:26.101]             seq.int <- base::seq.int
  [03:00:26.101]             signalCondition <- base::signalCondition
  [03:00:26.101]             sys.calls <- base::sys.calls
  [03:00:26.101]             Sys.time <- base::Sys.time
  [03:00:26.101]             `[[` <- base::`[[`
  [03:00:26.101]             `+` <- base::`+`
  [03:00:26.101]             `<<-` <- base::`<<-`
  [03:00:26.101]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.101]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.101]                   3L)]
  [03:00:26.101]             }
  [03:00:26.101]             function(cond) {
  [03:00:26.101]                 if (inherits(cond, "error")) {
  [03:00:26.101]                   sessionInformation <- function() {
  [03:00:26.101]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.101]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.101]                       search = base::search(), system = base::Sys.info())
  [03:00:26.101]                   }
  [03:00:26.101]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.101]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.101]                     cond$call), session = sessionInformation(), 
  [03:00:26.101]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.101]                   signalCondition(cond)
  [03:00:26.101]                 }
  [03:00:26.101]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.101]                 ))) {
  [03:00:26.101]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.101]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.101]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.101]                   if (!signal) {
  [03:00:26.101]                     muffleCondition <- function (cond) 
  [03:00:26.101]                     {
  [03:00:26.101]                       inherits <- base::inherits
  [03:00:26.101]                       invokeRestart <- base::invokeRestart
  [03:00:26.101]                       muffled <- FALSE
  [03:00:26.101]                       if (inherits(cond, "message")) {
  [03:00:26.101]                         invokeRestart("muffleMessage")
  [03:00:26.101]                         muffled <- TRUE
  [03:00:26.101]                       }
  [03:00:26.101]                       else if (inherits(cond, "warning")) {
  [03:00:26.101]                         invokeRestart("muffleWarning")
  [03:00:26.101]                         muffled <- TRUE
  [03:00:26.101]                       }
  [03:00:26.101]                       else if (inherits(cond, "condition")) {
  [03:00:26.101]                         computeRestarts <- base::computeRestarts
  [03:00:26.101]                         grepl <- base::grepl
  [03:00:26.101]                         is.null <- base::is.null
  [03:00:26.101]                         restarts <- computeRestarts(cond)
  [03:00:26.101]                         for (restart in restarts) {
  [03:00:26.101]                           name <- restart$name
  [03:00:26.101]                           if (is.null(name)) 
  [03:00:26.101]                             next
  [03:00:26.101]                           if (!grepl("^muffle", name)) 
  [03:00:26.101]                             next
  [03:00:26.101]                           invokeRestart(restart)
  [03:00:26.101]                           muffled <- TRUE
  [03:00:26.101]                           break
  [03:00:26.101]                         }
  [03:00:26.101]                       }
  [03:00:26.101]                       invisible(muffled)
  [03:00:26.101]                     }
  [03:00:26.101]                     muffleCondition(cond)
  [03:00:26.101]                   }
  [03:00:26.101]                 }
  [03:00:26.101]             }
  [03:00:26.101]         }))
  [03:00:26.101]     }, error = function(ex) {
  [03:00:26.101]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.101]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.101]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.101]     }, finally = {
  [03:00:26.101]         {
  [03:00:26.101]             NULL
  [03:00:26.101]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.101]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.101]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.101]                 label = NULL, ...) 
  [03:00:26.101]             {
  [03:00:26.101]                 if (substitute) 
  [03:00:26.101]                   expr <- substitute(expr)
  [03:00:26.101]                 local <- as.logical(local)
  [03:00:26.101]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.101]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.101]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.101]                   label = label, ...)
  [03:00:26.101]                 if (!future$lazy) 
  [03:00:26.101]                   future <- run(future)
  [03:00:26.101]                 invisible(future)
  [03:00:26.101]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.101]         }
  [03:00:26.101]         base::options(...future.oldOptions)
  [03:00:26.101]     })
  [03:00:26.101]     Sys.time
  [03:00:26.101]     if (base::is.na(NA)) {
  [03:00:26.101]     }
  [03:00:26.101]     else {
  [03:00:26.101]         base::sink(type = "output", split = FALSE)
  [03:00:26.101]         if (NA) {
  [03:00:26.101]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.101]         }
  [03:00:26.101]         else {
  [03:00:26.101]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.101]         }
  [03:00:26.101]         base::close(...future.stdout)
  [03:00:26.101]         ...future.stdout <- NULL
  [03:00:26.101]     }
  [03:00:26.101]     ...future.result$conditions <- ...future.conditions
  [03:00:26.101]     ...future.result
  [03:00:26.101] }
  [03:00:26.112] plan(): Setting new future strategy stack:
  [03:00:26.115] List of future strategies:
  [03:00:26.115] 1. sequential:
  [03:00:26.115]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.115]    - tweaked: FALSE
  [03:00:26.115]    - call: NULL
  [03:00:26.120] plan(): nbrOfWorkers() = 1
  [03:00:26.124] plan(): Setting new future strategy stack:
  [03:00:26.127] List of future strategies:
  [03:00:26.127] 1. sequential:
  [03:00:26.127]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.127]    - tweaked: FALSE
  [03:00:26.127]    - call: NULL
  [03:00:26.132] plan(): nbrOfWorkers() = 1
  [03:00:26.136] SequentialFuture started (and completed)
  [03:00:26.140] plan(): Setting new future strategy stack:
  [03:00:26.143] List of future strategies:
  [03:00:26.143] 1. sequential:
  [03:00:26.143]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.143]    - tweaked: FALSE
  [03:00:26.143]    - call: NULL
  [03:00:26.148] plan(): nbrOfWorkers() = 1
  [03:00:26.151] SequentialFuture started (and completed)
  [03:00:26.161] Packages needed by the future expression (n = 0): <none>
  [03:00:26.164] Packages needed by future strategies (n = 0): <none>
  [03:00:26.174] {
  [03:00:26.174]     {
  [03:00:26.174]         ...future.startTime <- base::Sys.time()
  [03:00:26.174]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.174]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.174]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.174]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.174]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.174]         {
  [03:00:26.174]             {
  [03:00:26.174]                 base::local({
  [03:00:26.174]                   has_future <- base::requireNamespace("future", 
  [03:00:26.174]                     quietly = TRUE)
  [03:00:26.174]                   version <- if (has_future) 
  [03:00:26.174]                     utils::packageVersion("future")
  [03:00:26.174]                   else NULL
  [03:00:26.174]                   if (!has_future || version < "1.8.0") {
  [03:00:26.174]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.174]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.174]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.174]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.174]                         "release", "version")], collapse = " "), 
  [03:00:26.174]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.174]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.174]                       info)
  [03:00:26.174]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.174]                     if (!has_future) {
  [03:00:26.174]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.174]                         info)
  [03:00:26.174]                     }
  [03:00:26.174]                     else {
  [03:00:26.174]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.174]                         info, version)
  [03:00:26.174]                     }
  [03:00:26.174]                     base::stop(msg)
  [03:00:26.174]                   }
  [03:00:26.174]                 })
  [03:00:26.174]             }
  [03:00:26.174]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.174]         }
  [03:00:26.174]     }
  [03:00:26.174]     if (base::is.na(NA)) {
  [03:00:26.174]     }
  [03:00:26.174]     else {
  [03:00:26.174]         if (NA) {
  [03:00:26.174]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.174]                 open = "w")
  [03:00:26.174]         }
  [03:00:26.174]         else {
  [03:00:26.174]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.174]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.174]         }
  [03:00:26.174]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.174]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.174]             base::sink(type = "output", split = FALSE)
  [03:00:26.174]             base::close(...future.stdout)
  [03:00:26.174]         }, add = TRUE)
  [03:00:26.174]     }
  [03:00:26.174]     ...future.frame <- base::sys.nframe()
  [03:00:26.174]     ...future.conditions <- base::list()
  [03:00:26.174]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.174]     ...future.result <- base::tryCatch({
  [03:00:26.174]         base::withCallingHandlers({
  [03:00:26.174]             ...future.value <- base::withVisible(base::local({
  [03:00:26.174]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.174]             }))
  [03:00:26.174]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.174]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.174]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.174]                 version = "1.8")
  [03:00:26.174]         }, condition = base::local({
  [03:00:26.174]             c <- base::c
  [03:00:26.174]             inherits <- base::inherits
  [03:00:26.174]             invokeRestart <- base::invokeRestart
  [03:00:26.174]             length <- base::length
  [03:00:26.174]             list <- base::list
  [03:00:26.174]             seq.int <- base::seq.int
  [03:00:26.174]             signalCondition <- base::signalCondition
  [03:00:26.174]             sys.calls <- base::sys.calls
  [03:00:26.174]             Sys.time <- base::Sys.time
  [03:00:26.174]             `[[` <- base::`[[`
  [03:00:26.174]             `+` <- base::`+`
  [03:00:26.174]             `<<-` <- base::`<<-`
  [03:00:26.174]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.174]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.174]                   3L)]
  [03:00:26.174]             }
  [03:00:26.174]             function(cond) {
  [03:00:26.174]                 if (inherits(cond, "error")) {
  [03:00:26.174]                   sessionInformation <- function() {
  [03:00:26.174]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.174]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.174]                       search = base::search(), system = base::Sys.info())
  [03:00:26.174]                   }
  [03:00:26.174]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.174]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.174]                     cond$call), session = sessionInformation(), 
  [03:00:26.174]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.174]                   signalCondition(cond)
  [03:00:26.174]                 }
  [03:00:26.174]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.174]                 ))) {
  [03:00:26.174]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.174]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.174]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.174]                   if (!signal) {
  [03:00:26.174]                     muffleCondition <- function (cond) 
  [03:00:26.174]                     {
  [03:00:26.174]                       inherits <- base::inherits
  [03:00:26.174]                       invokeRestart <- base::invokeRestart
  [03:00:26.174]                       muffled <- FALSE
  [03:00:26.174]                       if (inherits(cond, "message")) {
  [03:00:26.174]                         invokeRestart("muffleMessage")
  [03:00:26.174]                         muffled <- TRUE
  [03:00:26.174]                       }
  [03:00:26.174]                       else if (inherits(cond, "warning")) {
  [03:00:26.174]                         invokeRestart("muffleWarning")
  [03:00:26.174]                         muffled <- TRUE
  [03:00:26.174]                       }
  [03:00:26.174]                       else if (inherits(cond, "condition")) {
  [03:00:26.174]                         computeRestarts <- base::computeRestarts
  [03:00:26.174]                         grepl <- base::grepl
  [03:00:26.174]                         is.null <- base::is.null
  [03:00:26.174]                         restarts <- computeRestarts(cond)
  [03:00:26.174]                         for (restart in restarts) {
  [03:00:26.174]                           name <- restart$name
  [03:00:26.174]                           if (is.null(name)) 
  [03:00:26.174]                             next
  [03:00:26.174]                           if (!grepl("^muffle", name)) 
  [03:00:26.174]                             next
  [03:00:26.174]                           invokeRestart(restart)
  [03:00:26.174]                           muffled <- TRUE
  [03:00:26.174]                           break
  [03:00:26.174]                         }
  [03:00:26.174]                       }
  [03:00:26.174]                       invisible(muffled)
  [03:00:26.174]                     }
  [03:00:26.174]                     muffleCondition(cond)
  [03:00:26.174]                   }
  [03:00:26.174]                 }
  [03:00:26.174]             }
  [03:00:26.174]         }))
  [03:00:26.174]     }, error = function(ex) {
  [03:00:26.174]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.174]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.174]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.174]     }, finally = {
  [03:00:26.174]         {
  [03:00:26.174]             NULL
  [03:00:26.174]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.174]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.174]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.174]                 label = NULL, ...) 
  [03:00:26.174]             {
  [03:00:26.174]                 if (substitute) 
  [03:00:26.174]                   expr <- substitute(expr)
  [03:00:26.174]                 local <- as.logical(local)
  [03:00:26.174]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.174]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.174]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.174]                   label = label, ...)
  [03:00:26.174]                 if (!future$lazy) 
  [03:00:26.174]                   future <- run(future)
  [03:00:26.174]                 invisible(future)
  [03:00:26.174]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.174]         }
  [03:00:26.174]         base::options(...future.oldOptions)
  [03:00:26.174]     })
  [03:00:26.174]     Sys.time
  [03:00:26.174]     if (base::is.na(NA)) {
  [03:00:26.174]     }
  [03:00:26.174]     else {
  [03:00:26.174]         base::sink(type = "output", split = FALSE)
  [03:00:26.174]         if (NA) {
  [03:00:26.174]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.174]         }
  [03:00:26.174]         else {
  [03:00:26.174]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.174]         }
  [03:00:26.174]         base::close(...future.stdout)
  [03:00:26.174]         ...future.stdout <- NULL
  [03:00:26.174]     }
  [03:00:26.174]     ...future.result$conditions <- ...future.conditions
  [03:00:26.174]     ...future.result
  [03:00:26.174] }
  [03:00:26.185] plan(): Setting new future strategy stack:
  [03:00:26.188] List of future strategies:
  [03:00:26.188] 1. sequential:
  [03:00:26.188]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.188]    - tweaked: FALSE
  [03:00:26.188]    - call: NULL
  [03:00:26.193] plan(): nbrOfWorkers() = 1
  [03:00:26.198] plan(): Setting new future strategy stack:
  [03:00:26.201] List of future strategies:
  [03:00:26.201] 1. sequential:
  [03:00:26.201]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.201]    - tweaked: FALSE
  [03:00:26.201]    - call: NULL
  [03:00:26.205] plan(): nbrOfWorkers() = 1
  [03:00:26.209] SequentialFuture started (and completed)
  [03:00:26.213] plan(): Setting new future strategy stack:
  [03:00:26.216] List of future strategies:
  [03:00:26.216] 1. sequential:
  [03:00:26.216]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.216]    - tweaked: FALSE
  [03:00:26.216]    - call: NULL
  [03:00:26.221] plan(): nbrOfWorkers() = 1
  [03:00:26.224] SequentialFuture started (and completed)
  [03:00:26.230] Packages needed by the future expression (n = 0): <none>
  [03:00:26.233] Packages needed by future strategies (n = 0): <none>
  [03:00:26.243] {
  [03:00:26.243]     {
  [03:00:26.243]         ...future.startTime <- base::Sys.time()
  [03:00:26.243]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.243]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.243]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.243]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.243]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.243]         {
  [03:00:26.243]             {
  [03:00:26.243]                 base::local({
  [03:00:26.243]                   has_future <- base::requireNamespace("future", 
  [03:00:26.243]                     quietly = TRUE)
  [03:00:26.243]                   version <- if (has_future) 
  [03:00:26.243]                     utils::packageVersion("future")
  [03:00:26.243]                   else NULL
  [03:00:26.243]                   if (!has_future || version < "1.8.0") {
  [03:00:26.243]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.243]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.243]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.243]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.243]                         "release", "version")], collapse = " "), 
  [03:00:26.243]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.243]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.243]                       info)
  [03:00:26.243]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.243]                     if (!has_future) {
  [03:00:26.243]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.243]                         info)
  [03:00:26.243]                     }
  [03:00:26.243]                     else {
  [03:00:26.243]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.243]                         info, version)
  [03:00:26.243]                     }
  [03:00:26.243]                     base::stop(msg)
  [03:00:26.243]                   }
  [03:00:26.243]                 })
  [03:00:26.243]             }
  [03:00:26.243]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.243]         }
  [03:00:26.243]     }
  [03:00:26.243]     if (base::is.na(NA)) {
  [03:00:26.243]     }
  [03:00:26.243]     else {
  [03:00:26.243]         if (NA) {
  [03:00:26.243]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.243]                 open = "w")
  [03:00:26.243]         }
  [03:00:26.243]         else {
  [03:00:26.243]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.243]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.243]         }
  [03:00:26.243]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.243]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.243]             base::sink(type = "output", split = FALSE)
  [03:00:26.243]             base::close(...future.stdout)
  [03:00:26.243]         }, add = TRUE)
  [03:00:26.243]     }
  [03:00:26.243]     ...future.frame <- base::sys.nframe()
  [03:00:26.243]     ...future.conditions <- base::list()
  [03:00:26.243]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.243]     ...future.result <- base::tryCatch({
  [03:00:26.243]         base::withCallingHandlers({
  [03:00:26.243]             ...future.value <- base::withVisible(base::local({
  [03:00:26.243]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.243]             }))
  [03:00:26.243]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.243]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.243]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.243]                 version = "1.8")
  [03:00:26.243]         }, condition = base::local({
  [03:00:26.243]             c <- base::c
  [03:00:26.243]             inherits <- base::inherits
  [03:00:26.243]             invokeRestart <- base::invokeRestart
  [03:00:26.243]             length <- base::length
  [03:00:26.243]             list <- base::list
  [03:00:26.243]             seq.int <- base::seq.int
  [03:00:26.243]             signalCondition <- base::signalCondition
  [03:00:26.243]             sys.calls <- base::sys.calls
  [03:00:26.243]             Sys.time <- base::Sys.time
  [03:00:26.243]             `[[` <- base::`[[`
  [03:00:26.243]             `+` <- base::`+`
  [03:00:26.243]             `<<-` <- base::`<<-`
  [03:00:26.243]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.243]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.243]                   3L)]
  [03:00:26.243]             }
  [03:00:26.243]             function(cond) {
  [03:00:26.243]                 if (inherits(cond, "error")) {
  [03:00:26.243]                   sessionInformation <- function() {
  [03:00:26.243]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.243]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.243]                       search = base::search(), system = base::Sys.info())
  [03:00:26.243]                   }
  [03:00:26.243]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.243]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.243]                     cond$call), session = sessionInformation(), 
  [03:00:26.243]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.243]                   signalCondition(cond)
  [03:00:26.243]                 }
  [03:00:26.243]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.243]                 ))) {
  [03:00:26.243]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.243]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.243]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.243]                   if (!signal) {
  [03:00:26.243]                     muffleCondition <- function (cond) 
  [03:00:26.243]                     {
  [03:00:26.243]                       inherits <- base::inherits
  [03:00:26.243]                       invokeRestart <- base::invokeRestart
  [03:00:26.243]                       muffled <- FALSE
  [03:00:26.243]                       if (inherits(cond, "message")) {
  [03:00:26.243]                         invokeRestart("muffleMessage")
  [03:00:26.243]                         muffled <- TRUE
  [03:00:26.243]                       }
  [03:00:26.243]                       else if (inherits(cond, "warning")) {
  [03:00:26.243]                         invokeRestart("muffleWarning")
  [03:00:26.243]                         muffled <- TRUE
  [03:00:26.243]                       }
  [03:00:26.243]                       else if (inherits(cond, "condition")) {
  [03:00:26.243]                         computeRestarts <- base::computeRestarts
  [03:00:26.243]                         grepl <- base::grepl
  [03:00:26.243]                         is.null <- base::is.null
  [03:00:26.243]                         restarts <- computeRestarts(cond)
  [03:00:26.243]                         for (restart in restarts) {
  [03:00:26.243]                           name <- restart$name
  [03:00:26.243]                           if (is.null(name)) 
  [03:00:26.243]                             next
  [03:00:26.243]                           if (!grepl("^muffle", name)) 
  [03:00:26.243]                             next
  [03:00:26.243]                           invokeRestart(restart)
  [03:00:26.243]                           muffled <- TRUE
  [03:00:26.243]                           break
  [03:00:26.243]                         }
  [03:00:26.243]                       }
  [03:00:26.243]                       invisible(muffled)
  [03:00:26.243]                     }
  [03:00:26.243]                     muffleCondition(cond)
  [03:00:26.243]                   }
  [03:00:26.243]                 }
  [03:00:26.243]             }
  [03:00:26.243]         }))
  [03:00:26.243]     }, error = function(ex) {
  [03:00:26.243]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.243]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.243]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.243]     }, finally = {
  [03:00:26.243]         {
  [03:00:26.243]             NULL
  [03:00:26.243]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.243]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.243]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.243]                 label = NULL, ...) 
  [03:00:26.243]             {
  [03:00:26.243]                 if (substitute) 
  [03:00:26.243]                   expr <- substitute(expr)
  [03:00:26.243]                 local <- as.logical(local)
  [03:00:26.243]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.243]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.243]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.243]                   label = label, ...)
  [03:00:26.243]                 if (!future$lazy) 
  [03:00:26.243]                   future <- run(future)
  [03:00:26.243]                 invisible(future)
  [03:00:26.243]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.243]         }
  [03:00:26.243]         base::options(...future.oldOptions)
  [03:00:26.243]     })
  [03:00:26.243]     Sys.time
  [03:00:26.243]     if (base::is.na(NA)) {
  [03:00:26.243]     }
  [03:00:26.243]     else {
  [03:00:26.243]         base::sink(type = "output", split = FALSE)
  [03:00:26.243]         if (NA) {
  [03:00:26.243]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.243]         }
  [03:00:26.243]         else {
  [03:00:26.243]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.243]         }
  [03:00:26.243]         base::close(...future.stdout)
  [03:00:26.243]         ...future.stdout <- NULL
  [03:00:26.243]     }
  [03:00:26.243]     ...future.result$conditions <- ...future.conditions
  [03:00:26.243]     ...future.result
  [03:00:26.243] }
  [03:00:26.253] plan(): Setting new future strategy stack:
  [03:00:26.256] List of future strategies:
  [03:00:26.256] 1. sequential:
  [03:00:26.256]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.256]    - tweaked: FALSE
  [03:00:26.256]    - call: NULL
  [03:00:26.260] plan(): nbrOfWorkers() = 1
  [03:00:26.264] plan(): Setting new future strategy stack:
  [03:00:26.267] List of future strategies:
  [03:00:26.267] 1. sequential:
  [03:00:26.267]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.267]    - tweaked: FALSE
  [03:00:26.267]    - call: NULL
  [03:00:26.271] plan(): nbrOfWorkers() = 1
  [03:00:26.274] SequentialFuture started (and completed)
  [03:00:26.277] plan(): Setting new future strategy stack:
  [03:00:26.280] List of future strategies:
  [03:00:26.280] 1. sequential:
  [03:00:26.280]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.280]    - tweaked: FALSE
  [03:00:26.280]    - call: NULL
  [03:00:26.283] plan(): nbrOfWorkers() = 1
  [03:00:26.287] SequentialFuture started (and completed)
  [03:00:26.292] Packages needed by the future expression (n = 0): <none>
  [03:00:26.295] Packages needed by future strategies (n = 0): <none>
  [03:00:26.305] {
  [03:00:26.305]     {
  [03:00:26.305]         ...future.startTime <- base::Sys.time()
  [03:00:26.305]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.305]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.305]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.305]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.305]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.305]         {
  [03:00:26.305]             {
  [03:00:26.305]                 base::local({
  [03:00:26.305]                   has_future <- base::requireNamespace("future", 
  [03:00:26.305]                     quietly = TRUE)
  [03:00:26.305]                   version <- if (has_future) 
  [03:00:26.305]                     utils::packageVersion("future")
  [03:00:26.305]                   else NULL
  [03:00:26.305]                   if (!has_future || version < "1.8.0") {
  [03:00:26.305]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.305]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.305]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.305]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.305]                         "release", "version")], collapse = " "), 
  [03:00:26.305]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.305]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.305]                       info)
  [03:00:26.305]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.305]                     if (!has_future) {
  [03:00:26.305]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.305]                         info)
  [03:00:26.305]                     }
  [03:00:26.305]                     else {
  [03:00:26.305]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.305]                         info, version)
  [03:00:26.305]                     }
  [03:00:26.305]                     base::stop(msg)
  [03:00:26.305]                   }
  [03:00:26.305]                 })
  [03:00:26.305]             }
  [03:00:26.305]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.305]         }
  [03:00:26.305]     }
  [03:00:26.305]     if (base::is.na(NA)) {
  [03:00:26.305]     }
  [03:00:26.305]     else {
  [03:00:26.305]         if (NA) {
  [03:00:26.305]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.305]                 open = "w")
  [03:00:26.305]         }
  [03:00:26.305]         else {
  [03:00:26.305]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.305]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.305]         }
  [03:00:26.305]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.305]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.305]             base::sink(type = "output", split = FALSE)
  [03:00:26.305]             base::close(...future.stdout)
  [03:00:26.305]         }, add = TRUE)
  [03:00:26.305]     }
  [03:00:26.305]     ...future.frame <- base::sys.nframe()
  [03:00:26.305]     ...future.conditions <- base::list()
  [03:00:26.305]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.305]     ...future.result <- base::tryCatch({
  [03:00:26.305]         base::withCallingHandlers({
  [03:00:26.305]             ...future.value <- base::withVisible(base::local({
  [03:00:26.305]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.305]             }))
  [03:00:26.305]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.305]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.305]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.305]                 version = "1.8")
  [03:00:26.305]         }, condition = base::local({
  [03:00:26.305]             c <- base::c
  [03:00:26.305]             inherits <- base::inherits
  [03:00:26.305]             invokeRestart <- base::invokeRestart
  [03:00:26.305]             length <- base::length
  [03:00:26.305]             list <- base::list
  [03:00:26.305]             seq.int <- base::seq.int
  [03:00:26.305]             signalCondition <- base::signalCondition
  [03:00:26.305]             sys.calls <- base::sys.calls
  [03:00:26.305]             Sys.time <- base::Sys.time
  [03:00:26.305]             `[[` <- base::`[[`
  [03:00:26.305]             `+` <- base::`+`
  [03:00:26.305]             `<<-` <- base::`<<-`
  [03:00:26.305]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.305]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.305]                   3L)]
  [03:00:26.305]             }
  [03:00:26.305]             function(cond) {
  [03:00:26.305]                 if (inherits(cond, "error")) {
  [03:00:26.305]                   sessionInformation <- function() {
  [03:00:26.305]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.305]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.305]                       search = base::search(), system = base::Sys.info())
  [03:00:26.305]                   }
  [03:00:26.305]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.305]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.305]                     cond$call), session = sessionInformation(), 
  [03:00:26.305]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.305]                   signalCondition(cond)
  [03:00:26.305]                 }
  [03:00:26.305]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.305]                 ))) {
  [03:00:26.305]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.305]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.305]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.305]                   if (!signal) {
  [03:00:26.305]                     muffleCondition <- function (cond) 
  [03:00:26.305]                     {
  [03:00:26.305]                       inherits <- base::inherits
  [03:00:26.305]                       invokeRestart <- base::invokeRestart
  [03:00:26.305]                       muffled <- FALSE
  [03:00:26.305]                       if (inherits(cond, "message")) {
  [03:00:26.305]                         invokeRestart("muffleMessage")
  [03:00:26.305]                         muffled <- TRUE
  [03:00:26.305]                       }
  [03:00:26.305]                       else if (inherits(cond, "warning")) {
  [03:00:26.305]                         invokeRestart("muffleWarning")
  [03:00:26.305]                         muffled <- TRUE
  [03:00:26.305]                       }
  [03:00:26.305]                       else if (inherits(cond, "condition")) {
  [03:00:26.305]                         computeRestarts <- base::computeRestarts
  [03:00:26.305]                         grepl <- base::grepl
  [03:00:26.305]                         is.null <- base::is.null
  [03:00:26.305]                         restarts <- computeRestarts(cond)
  [03:00:26.305]                         for (restart in restarts) {
  [03:00:26.305]                           name <- restart$name
  [03:00:26.305]                           if (is.null(name)) 
  [03:00:26.305]                             next
  [03:00:26.305]                           if (!grepl("^muffle", name)) 
  [03:00:26.305]                             next
  [03:00:26.305]                           invokeRestart(restart)
  [03:00:26.305]                           muffled <- TRUE
  [03:00:26.305]                           break
  [03:00:26.305]                         }
  [03:00:26.305]                       }
  [03:00:26.305]                       invisible(muffled)
  [03:00:26.305]                     }
  [03:00:26.305]                     muffleCondition(cond)
  [03:00:26.305]                   }
  [03:00:26.305]                 }
  [03:00:26.305]             }
  [03:00:26.305]         }))
  [03:00:26.305]     }, error = function(ex) {
  [03:00:26.305]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.305]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.305]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.305]     }, finally = {
  [03:00:26.305]         {
  [03:00:26.305]             NULL
  [03:00:26.305]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.305]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.305]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.305]                 label = NULL, ...) 
  [03:00:26.305]             {
  [03:00:26.305]                 if (substitute) 
  [03:00:26.305]                   expr <- substitute(expr)
  [03:00:26.305]                 local <- as.logical(local)
  [03:00:26.305]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.305]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.305]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.305]                   label = label, ...)
  [03:00:26.305]                 if (!future$lazy) 
  [03:00:26.305]                   future <- run(future)
  [03:00:26.305]                 invisible(future)
  [03:00:26.305]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.305]         }
  [03:00:26.305]         base::options(...future.oldOptions)
  [03:00:26.305]     })
  [03:00:26.305]     Sys.time
  [03:00:26.305]     if (base::is.na(NA)) {
  [03:00:26.305]     }
  [03:00:26.305]     else {
  [03:00:26.305]         base::sink(type = "output", split = FALSE)
  [03:00:26.305]         if (NA) {
  [03:00:26.305]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.305]         }
  [03:00:26.305]         else {
  [03:00:26.305]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.305]         }
  [03:00:26.305]         base::close(...future.stdout)
  [03:00:26.305]         ...future.stdout <- NULL
  [03:00:26.305]     }
  [03:00:26.305]     ...future.result$conditions <- ...future.conditions
  [03:00:26.305]     ...future.result
  [03:00:26.305] }
  [03:00:26.319] plan(): Setting new future strategy stack:
  [03:00:26.322] List of future strategies:
  [03:00:26.322] 1. sequential:
  [03:00:26.322]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.322]    - tweaked: FALSE
  [03:00:26.322]    - call: NULL
  [03:00:26.327] plan(): nbrOfWorkers() = 1
  [03:00:26.331] plan(): Setting new future strategy stack:
  [03:00:26.334] List of future strategies:
  [03:00:26.334] 1. sequential:
  [03:00:26.334]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.334]    - tweaked: FALSE
  [03:00:26.334]    - call: NULL
  [03:00:26.338] plan(): nbrOfWorkers() = 1
  [03:00:26.341] SequentialFuture started (and completed)
  [03:00:26.345] plan(): Setting new future strategy stack:
  [03:00:26.348] List of future strategies:
  [03:00:26.348] 1. sequential:
  [03:00:26.348]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.348]    - tweaked: FALSE
  [03:00:26.348]    - call: NULL
  [03:00:26.352] plan(): nbrOfWorkers() = 1
  [03:00:26.355] SequentialFuture started (and completed)
  [03:00:26.360] Packages needed by the future expression (n = 0): <none>
  [03:00:26.363] Packages needed by future strategies (n = 0): <none>
  [03:00:26.372] {
  [03:00:26.372]     {
  [03:00:26.372]         ...future.startTime <- base::Sys.time()
  [03:00:26.372]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.372]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.372]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.372]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.372]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.372]         {
  [03:00:26.372]             {
  [03:00:26.372]                 base::local({
  [03:00:26.372]                   has_future <- base::requireNamespace("future", 
  [03:00:26.372]                     quietly = TRUE)
  [03:00:26.372]                   version <- if (has_future) 
  [03:00:26.372]                     utils::packageVersion("future")
  [03:00:26.372]                   else NULL
  [03:00:26.372]                   if (!has_future || version < "1.8.0") {
  [03:00:26.372]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.372]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.372]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.372]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.372]                         "release", "version")], collapse = " "), 
  [03:00:26.372]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.372]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.372]                       info)
  [03:00:26.372]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.372]                     if (!has_future) {
  [03:00:26.372]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.372]                         info)
  [03:00:26.372]                     }
  [03:00:26.372]                     else {
  [03:00:26.372]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.372]                         info, version)
  [03:00:26.372]                     }
  [03:00:26.372]                     base::stop(msg)
  [03:00:26.372]                   }
  [03:00:26.372]                 })
  [03:00:26.372]             }
  [03:00:26.372]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.372]         }
  [03:00:26.372]     }
  [03:00:26.372]     if (base::is.na(NA)) {
  [03:00:26.372]     }
  [03:00:26.372]     else {
  [03:00:26.372]         if (NA) {
  [03:00:26.372]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.372]                 open = "w")
  [03:00:26.372]         }
  [03:00:26.372]         else {
  [03:00:26.372]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.372]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.372]         }
  [03:00:26.372]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.372]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.372]             base::sink(type = "output", split = FALSE)
  [03:00:26.372]             base::close(...future.stdout)
  [03:00:26.372]         }, add = TRUE)
  [03:00:26.372]     }
  [03:00:26.372]     ...future.frame <- base::sys.nframe()
  [03:00:26.372]     ...future.conditions <- base::list()
  [03:00:26.372]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.372]     ...future.result <- base::tryCatch({
  [03:00:26.372]         base::withCallingHandlers({
  [03:00:26.372]             ...future.value <- base::withVisible(base::local({
  [03:00:26.372]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.372]             }))
  [03:00:26.372]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.372]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.372]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.372]                 version = "1.8")
  [03:00:26.372]         }, condition = base::local({
  [03:00:26.372]             c <- base::c
  [03:00:26.372]             inherits <- base::inherits
  [03:00:26.372]             invokeRestart <- base::invokeRestart
  [03:00:26.372]             length <- base::length
  [03:00:26.372]             list <- base::list
  [03:00:26.372]             seq.int <- base::seq.int
  [03:00:26.372]             signalCondition <- base::signalCondition
  [03:00:26.372]             sys.calls <- base::sys.calls
  [03:00:26.372]             Sys.time <- base::Sys.time
  [03:00:26.372]             `[[` <- base::`[[`
  [03:00:26.372]             `+` <- base::`+`
  [03:00:26.372]             `<<-` <- base::`<<-`
  [03:00:26.372]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.372]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.372]                   3L)]
  [03:00:26.372]             }
  [03:00:26.372]             function(cond) {
  [03:00:26.372]                 if (inherits(cond, "error")) {
  [03:00:26.372]                   sessionInformation <- function() {
  [03:00:26.372]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.372]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.372]                       search = base::search(), system = base::Sys.info())
  [03:00:26.372]                   }
  [03:00:26.372]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.372]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.372]                     cond$call), session = sessionInformation(), 
  [03:00:26.372]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.372]                   signalCondition(cond)
  [03:00:26.372]                 }
  [03:00:26.372]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.372]                 ))) {
  [03:00:26.372]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.372]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.372]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.372]                   if (!signal) {
  [03:00:26.372]                     muffleCondition <- function (cond) 
  [03:00:26.372]                     {
  [03:00:26.372]                       inherits <- base::inherits
  [03:00:26.372]                       invokeRestart <- base::invokeRestart
  [03:00:26.372]                       muffled <- FALSE
  [03:00:26.372]                       if (inherits(cond, "message")) {
  [03:00:26.372]                         invokeRestart("muffleMessage")
  [03:00:26.372]                         muffled <- TRUE
  [03:00:26.372]                       }
  [03:00:26.372]                       else if (inherits(cond, "warning")) {
  [03:00:26.372]                         invokeRestart("muffleWarning")
  [03:00:26.372]                         muffled <- TRUE
  [03:00:26.372]                       }
  [03:00:26.372]                       else if (inherits(cond, "condition")) {
  [03:00:26.372]                         computeRestarts <- base::computeRestarts
  [03:00:26.372]                         grepl <- base::grepl
  [03:00:26.372]                         is.null <- base::is.null
  [03:00:26.372]                         restarts <- computeRestarts(cond)
  [03:00:26.372]                         for (restart in restarts) {
  [03:00:26.372]                           name <- restart$name
  [03:00:26.372]                           if (is.null(name)) 
  [03:00:26.372]                             next
  [03:00:26.372]                           if (!grepl("^muffle", name)) 
  [03:00:26.372]                             next
  [03:00:26.372]                           invokeRestart(restart)
  [03:00:26.372]                           muffled <- TRUE
  [03:00:26.372]                           break
  [03:00:26.372]                         }
  [03:00:26.372]                       }
  [03:00:26.372]                       invisible(muffled)
  [03:00:26.372]                     }
  [03:00:26.372]                     muffleCondition(cond)
  [03:00:26.372]                   }
  [03:00:26.372]                 }
  [03:00:26.372]             }
  [03:00:26.372]         }))
  [03:00:26.372]     }, error = function(ex) {
  [03:00:26.372]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.372]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.372]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.372]     }, finally = {
  [03:00:26.372]         {
  [03:00:26.372]             NULL
  [03:00:26.372]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.372]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.372]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.372]                 label = NULL, ...) 
  [03:00:26.372]             {
  [03:00:26.372]                 if (substitute) 
  [03:00:26.372]                   expr <- substitute(expr)
  [03:00:26.372]                 local <- as.logical(local)
  [03:00:26.372]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.372]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.372]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.372]                   label = label, ...)
  [03:00:26.372]                 if (!future$lazy) 
  [03:00:26.372]                   future <- run(future)
  [03:00:26.372]                 invisible(future)
  [03:00:26.372]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.372]         }
  [03:00:26.372]         base::options(...future.oldOptions)
  [03:00:26.372]     })
  [03:00:26.372]     Sys.time
  [03:00:26.372]     if (base::is.na(NA)) {
  [03:00:26.372]     }
  [03:00:26.372]     else {
  [03:00:26.372]         base::sink(type = "output", split = FALSE)
  [03:00:26.372]         if (NA) {
  [03:00:26.372]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.372]         }
  [03:00:26.372]         else {
  [03:00:26.372]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.372]         }
  [03:00:26.372]         base::close(...future.stdout)
  [03:00:26.372]         ...future.stdout <- NULL
  [03:00:26.372]     }
  [03:00:26.372]     ...future.result$conditions <- ...future.conditions
  [03:00:26.372]     ...future.result
  [03:00:26.372] }
  [03:00:26.382] plan(): Setting new future strategy stack:
  [03:00:26.385] List of future strategies:
  [03:00:26.385] 1. sequential:
  [03:00:26.385]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.385]    - tweaked: FALSE
  [03:00:26.385]    - call: NULL
  [03:00:26.388] plan(): nbrOfWorkers() = 1
  [03:00:26.392] plan(): Setting new future strategy stack:
  [03:00:26.395] List of future strategies:
  [03:00:26.395] 1. sequential:
  [03:00:26.395]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.395]    - tweaked: FALSE
  [03:00:26.395]    - call: NULL
  [03:00:26.399] plan(): nbrOfWorkers() = 1
  [03:00:26.401] SequentialFuture started (and completed)
  [03:00:26.405] plan(): Setting new future strategy stack:
  [03:00:26.407] List of future strategies:
  [03:00:26.407] 1. sequential:
  [03:00:26.407]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.407]    - tweaked: FALSE
  [03:00:26.407]    - call: NULL
  [03:00:26.411] plan(): nbrOfWorkers() = 1
  [03:00:26.413] SequentialFuture started (and completed)
  [03:00:26.418] Packages needed by the future expression (n = 0): <none>
  [03:00:26.421] Packages needed by future strategies (n = 0): <none>
  [03:00:26.430] {
  [03:00:26.430]     {
  [03:00:26.430]         ...future.startTime <- base::Sys.time()
  [03:00:26.430]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.430]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.430]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.430]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.430]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.430]         {
  [03:00:26.430]             {
  [03:00:26.430]                 base::local({
  [03:00:26.430]                   has_future <- base::requireNamespace("future", 
  [03:00:26.430]                     quietly = TRUE)
  [03:00:26.430]                   version <- if (has_future) 
  [03:00:26.430]                     utils::packageVersion("future")
  [03:00:26.430]                   else NULL
  [03:00:26.430]                   if (!has_future || version < "1.8.0") {
  [03:00:26.430]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.430]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.430]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.430]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.430]                         "release", "version")], collapse = " "), 
  [03:00:26.430]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.430]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.430]                       info)
  [03:00:26.430]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.430]                     if (!has_future) {
  [03:00:26.430]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.430]                         info)
  [03:00:26.430]                     }
  [03:00:26.430]                     else {
  [03:00:26.430]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.430]                         info, version)
  [03:00:26.430]                     }
  [03:00:26.430]                     base::stop(msg)
  [03:00:26.430]                   }
  [03:00:26.430]                 })
  [03:00:26.430]             }
  [03:00:26.430]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.430]         }
  [03:00:26.430]     }
  [03:00:26.430]     if (base::is.na(NA)) {
  [03:00:26.430]     }
  [03:00:26.430]     else {
  [03:00:26.430]         if (NA) {
  [03:00:26.430]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.430]                 open = "w")
  [03:00:26.430]         }
  [03:00:26.430]         else {
  [03:00:26.430]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.430]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.430]         }
  [03:00:26.430]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.430]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.430]             base::sink(type = "output", split = FALSE)
  [03:00:26.430]             base::close(...future.stdout)
  [03:00:26.430]         }, add = TRUE)
  [03:00:26.430]     }
  [03:00:26.430]     ...future.frame <- base::sys.nframe()
  [03:00:26.430]     ...future.conditions <- base::list()
  [03:00:26.430]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.430]     ...future.result <- base::tryCatch({
  [03:00:26.430]         base::withCallingHandlers({
  [03:00:26.430]             ...future.value <- base::withVisible(base::local({
  [03:00:26.430]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.430]             }))
  [03:00:26.430]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.430]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.430]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.430]                 version = "1.8")
  [03:00:26.430]         }, condition = base::local({
  [03:00:26.430]             c <- base::c
  [03:00:26.430]             inherits <- base::inherits
  [03:00:26.430]             invokeRestart <- base::invokeRestart
  [03:00:26.430]             length <- base::length
  [03:00:26.430]             list <- base::list
  [03:00:26.430]             seq.int <- base::seq.int
  [03:00:26.430]             signalCondition <- base::signalCondition
  [03:00:26.430]             sys.calls <- base::sys.calls
  [03:00:26.430]             Sys.time <- base::Sys.time
  [03:00:26.430]             `[[` <- base::`[[`
  [03:00:26.430]             `+` <- base::`+`
  [03:00:26.430]             `<<-` <- base::`<<-`
  [03:00:26.430]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.430]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.430]                   3L)]
  [03:00:26.430]             }
  [03:00:26.430]             function(cond) {
  [03:00:26.430]                 if (inherits(cond, "error")) {
  [03:00:26.430]                   sessionInformation <- function() {
  [03:00:26.430]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.430]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.430]                       search = base::search(), system = base::Sys.info())
  [03:00:26.430]                   }
  [03:00:26.430]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.430]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.430]                     cond$call), session = sessionInformation(), 
  [03:00:26.430]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.430]                   signalCondition(cond)
  [03:00:26.430]                 }
  [03:00:26.430]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.430]                 ))) {
  [03:00:26.430]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.430]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.430]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.430]                   if (!signal) {
  [03:00:26.430]                     muffleCondition <- function (cond) 
  [03:00:26.430]                     {
  [03:00:26.430]                       inherits <- base::inherits
  [03:00:26.430]                       invokeRestart <- base::invokeRestart
  [03:00:26.430]                       muffled <- FALSE
  [03:00:26.430]                       if (inherits(cond, "message")) {
  [03:00:26.430]                         invokeRestart("muffleMessage")
  [03:00:26.430]                         muffled <- TRUE
  [03:00:26.430]                       }
  [03:00:26.430]                       else if (inherits(cond, "warning")) {
  [03:00:26.430]                         invokeRestart("muffleWarning")
  [03:00:26.430]                         muffled <- TRUE
  [03:00:26.430]                       }
  [03:00:26.430]                       else if (inherits(cond, "condition")) {
  [03:00:26.430]                         computeRestarts <- base::computeRestarts
  [03:00:26.430]                         grepl <- base::grepl
  [03:00:26.430]                         is.null <- base::is.null
  [03:00:26.430]                         restarts <- computeRestarts(cond)
  [03:00:26.430]                         for (restart in restarts) {
  [03:00:26.430]                           name <- restart$name
  [03:00:26.430]                           if (is.null(name)) 
  [03:00:26.430]                             next
  [03:00:26.430]                           if (!grepl("^muffle", name)) 
  [03:00:26.430]                             next
  [03:00:26.430]                           invokeRestart(restart)
  [03:00:26.430]                           muffled <- TRUE
  [03:00:26.430]                           break
  [03:00:26.430]                         }
  [03:00:26.430]                       }
  [03:00:26.430]                       invisible(muffled)
  [03:00:26.430]                     }
  [03:00:26.430]                     muffleCondition(cond)
  [03:00:26.430]                   }
  [03:00:26.430]                 }
  [03:00:26.430]             }
  [03:00:26.430]         }))
  [03:00:26.430]     }, error = function(ex) {
  [03:00:26.430]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.430]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.430]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.430]     }, finally = {
  [03:00:26.430]         {
  [03:00:26.430]             NULL
  [03:00:26.430]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.430]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.430]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.430]                 label = NULL, ...) 
  [03:00:26.430]             {
  [03:00:26.430]                 if (substitute) 
  [03:00:26.430]                   expr <- substitute(expr)
  [03:00:26.430]                 local <- as.logical(local)
  [03:00:26.430]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.430]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.430]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.430]                   label = label, ...)
  [03:00:26.430]                 if (!future$lazy) 
  [03:00:26.430]                   future <- run(future)
  [03:00:26.430]                 invisible(future)
  [03:00:26.430]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.430]         }
  [03:00:26.430]         base::options(...future.oldOptions)
  [03:00:26.430]     })
  [03:00:26.430]     Sys.time
  [03:00:26.430]     if (base::is.na(NA)) {
  [03:00:26.430]     }
  [03:00:26.430]     else {
  [03:00:26.430]         base::sink(type = "output", split = FALSE)
  [03:00:26.430]         if (NA) {
  [03:00:26.430]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.430]         }
  [03:00:26.430]         else {
  [03:00:26.430]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.430]         }
  [03:00:26.430]         base::close(...future.stdout)
  [03:00:26.430]         ...future.stdout <- NULL
  [03:00:26.430]     }
  [03:00:26.430]     ...future.result$conditions <- ...future.conditions
  [03:00:26.430]     ...future.result
  [03:00:26.430] }
  [03:00:26.439] plan(): Setting new future strategy stack:
  [03:00:26.442] List of future strategies:
  [03:00:26.442] 1. sequential:
  [03:00:26.442]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.442]    - tweaked: FALSE
  [03:00:26.442]    - call: NULL
  [03:00:26.445] plan(): nbrOfWorkers() = 1
  [03:00:26.448] plan(): Setting new future strategy stack:
  [03:00:26.451] List of future strategies:
  [03:00:26.451] 1. sequential:
  [03:00:26.451]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.451]    - tweaked: FALSE
  [03:00:26.451]    - call: NULL
  [03:00:26.454] plan(): nbrOfWorkers() = 1
  [03:00:26.457] SequentialFuture started (and completed)
  [03:00:26.460] plan(): Setting new future strategy stack:
  [03:00:26.462] List of future strategies:
  [03:00:26.462] 1. sequential:
  [03:00:26.462]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.462]    - tweaked: FALSE
  [03:00:26.462]    - call: NULL
  [03:00:26.466] plan(): nbrOfWorkers() = 1
  [03:00:26.469] SequentialFuture started (and completed)
  [03:00:26.473] Packages needed by the future expression (n = 0): <none>
  [03:00:26.476] Packages needed by future strategies (n = 0): <none>
  [03:00:26.498] {
  [03:00:26.498]     {
  [03:00:26.498]         ...future.startTime <- base::Sys.time()
  [03:00:26.498]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.498]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.498]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.498]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.498]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.498]         {
  [03:00:26.498]             {
  [03:00:26.498]                 base::local({
  [03:00:26.498]                   has_future <- base::requireNamespace("future", 
  [03:00:26.498]                     quietly = TRUE)
  [03:00:26.498]                   version <- if (has_future) 
  [03:00:26.498]                     utils::packageVersion("future")
  [03:00:26.498]                   else NULL
  [03:00:26.498]                   if (!has_future || version < "1.8.0") {
  [03:00:26.498]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.498]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.498]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.498]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.498]                         "release", "version")], collapse = " "), 
  [03:00:26.498]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.498]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.498]                       info)
  [03:00:26.498]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.498]                     if (!has_future) {
  [03:00:26.498]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.498]                         info)
  [03:00:26.498]                     }
  [03:00:26.498]                     else {
  [03:00:26.498]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.498]                         info, version)
  [03:00:26.498]                     }
  [03:00:26.498]                     base::stop(msg)
  [03:00:26.498]                   }
  [03:00:26.498]                 })
  [03:00:26.498]             }
  [03:00:26.498]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.498]         }
  [03:00:26.498]     }
  [03:00:26.498]     if (base::is.na(NA)) {
  [03:00:26.498]     }
  [03:00:26.498]     else {
  [03:00:26.498]         if (NA) {
  [03:00:26.498]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.498]                 open = "w")
  [03:00:26.498]         }
  [03:00:26.498]         else {
  [03:00:26.498]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.498]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.498]         }
  [03:00:26.498]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.498]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.498]             base::sink(type = "output", split = FALSE)
  [03:00:26.498]             base::close(...future.stdout)
  [03:00:26.498]         }, add = TRUE)
  [03:00:26.498]     }
  [03:00:26.498]     ...future.frame <- base::sys.nframe()
  [03:00:26.498]     ...future.conditions <- base::list()
  [03:00:26.498]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.498]     ...future.result <- base::tryCatch({
  [03:00:26.498]         base::withCallingHandlers({
  [03:00:26.498]             ...future.value <- base::withVisible(base::local({
  [03:00:26.498]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.498]             }))
  [03:00:26.498]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.498]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.498]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.498]                 version = "1.8")
  [03:00:26.498]         }, condition = base::local({
  [03:00:26.498]             c <- base::c
  [03:00:26.498]             inherits <- base::inherits
  [03:00:26.498]             invokeRestart <- base::invokeRestart
  [03:00:26.498]             length <- base::length
  [03:00:26.498]             list <- base::list
  [03:00:26.498]             seq.int <- base::seq.int
  [03:00:26.498]             signalCondition <- base::signalCondition
  [03:00:26.498]             sys.calls <- base::sys.calls
  [03:00:26.498]             Sys.time <- base::Sys.time
  [03:00:26.498]             `[[` <- base::`[[`
  [03:00:26.498]             `+` <- base::`+`
  [03:00:26.498]             `<<-` <- base::`<<-`
  [03:00:26.498]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.498]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.498]                   3L)]
  [03:00:26.498]             }
  [03:00:26.498]             function(cond) {
  [03:00:26.498]                 if (inherits(cond, "error")) {
  [03:00:26.498]                   sessionInformation <- function() {
  [03:00:26.498]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.498]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.498]                       search = base::search(), system = base::Sys.info())
  [03:00:26.498]                   }
  [03:00:26.498]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.498]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.498]                     cond$call), session = sessionInformation(), 
  [03:00:26.498]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.498]                   signalCondition(cond)
  [03:00:26.498]                 }
  [03:00:26.498]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.498]                 ))) {
  [03:00:26.498]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.498]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.498]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.498]                   if (!signal) {
  [03:00:26.498]                     muffleCondition <- function (cond) 
  [03:00:26.498]                     {
  [03:00:26.498]                       inherits <- base::inherits
  [03:00:26.498]                       invokeRestart <- base::invokeRestart
  [03:00:26.498]                       muffled <- FALSE
  [03:00:26.498]                       if (inherits(cond, "message")) {
  [03:00:26.498]                         invokeRestart("muffleMessage")
  [03:00:26.498]                         muffled <- TRUE
  [03:00:26.498]                       }
  [03:00:26.498]                       else if (inherits(cond, "warning")) {
  [03:00:26.498]                         invokeRestart("muffleWarning")
  [03:00:26.498]                         muffled <- TRUE
  [03:00:26.498]                       }
  [03:00:26.498]                       else if (inherits(cond, "condition")) {
  [03:00:26.498]                         computeRestarts <- base::computeRestarts
  [03:00:26.498]                         grepl <- base::grepl
  [03:00:26.498]                         is.null <- base::is.null
  [03:00:26.498]                         restarts <- computeRestarts(cond)
  [03:00:26.498]                         for (restart in restarts) {
  [03:00:26.498]                           name <- restart$name
  [03:00:26.498]                           if (is.null(name)) 
  [03:00:26.498]                             next
  [03:00:26.498]                           if (!grepl("^muffle", name)) 
  [03:00:26.498]                             next
  [03:00:26.498]                           invokeRestart(restart)
  [03:00:26.498]                           muffled <- TRUE
  [03:00:26.498]                           break
  [03:00:26.498]                         }
  [03:00:26.498]                       }
  [03:00:26.498]                       invisible(muffled)
  [03:00:26.498]                     }
  [03:00:26.498]                     muffleCondition(cond)
  [03:00:26.498]                   }
  [03:00:26.498]                 }
  [03:00:26.498]             }
  [03:00:26.498]         }))
  [03:00:26.498]     }, error = function(ex) {
  [03:00:26.498]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.498]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.498]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.498]     }, finally = {
  [03:00:26.498]         {
  [03:00:26.498]             NULL
  [03:00:26.498]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.498]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.498]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.498]                 label = NULL, ...) 
  [03:00:26.498]             {
  [03:00:26.498]                 if (substitute) 
  [03:00:26.498]                   expr <- substitute(expr)
  [03:00:26.498]                 local <- as.logical(local)
  [03:00:26.498]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.498]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.498]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.498]                   label = label, ...)
  [03:00:26.498]                 if (!future$lazy) 
  [03:00:26.498]                   future <- run(future)
  [03:00:26.498]                 invisible(future)
  [03:00:26.498]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.498]         }
  [03:00:26.498]         base::options(...future.oldOptions)
  [03:00:26.498]     })
  [03:00:26.498]     Sys.time
  [03:00:26.498]     if (base::is.na(NA)) {
  [03:00:26.498]     }
  [03:00:26.498]     else {
  [03:00:26.498]         base::sink(type = "output", split = FALSE)
  [03:00:26.498]         if (NA) {
  [03:00:26.498]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.498]         }
  [03:00:26.498]         else {
  [03:00:26.498]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.498]         }
  [03:00:26.498]         base::close(...future.stdout)
  [03:00:26.498]         ...future.stdout <- NULL
  [03:00:26.498]     }
  [03:00:26.498]     ...future.result$conditions <- ...future.conditions
  [03:00:26.498]     ...future.result
  [03:00:26.498] }
  [03:00:26.507] plan(): Setting new future strategy stack:
  [03:00:26.522] List of future strategies:
  [03:00:26.522] 1. sequential:
  [03:00:26.522]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.522]    - tweaked: FALSE
  [03:00:26.522]    - call: NULL
  [03:00:26.526] plan(): nbrOfWorkers() = 1
  [03:00:26.529] plan(): Setting new future strategy stack:
  [03:00:26.531] List of future strategies:
  [03:00:26.531] 1. sequential:
  [03:00:26.531]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.531]    - tweaked: FALSE
  [03:00:26.531]    - call: NULL
  [03:00:26.537] plan(): nbrOfWorkers() = 1
  [03:00:26.539] SequentialFuture started (and completed)
  [03:00:26.552] plan(): Setting new future strategy stack:
  [03:00:26.554] List of future strategies:
  [03:00:26.554] 1. sequential:
  [03:00:26.554]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.554]    - tweaked: FALSE
  [03:00:26.554]    - call: NULL
  [03:00:26.565] plan(): nbrOfWorkers() = 1
  [03:00:26.567] SequentialFuture started (and completed)
  [03:00:26.582] Packages needed by the future expression (n = 0): <none>
  [03:00:26.584] Packages needed by future strategies (n = 0): <none>
  [03:00:26.593] {
  [03:00:26.593]     {
  [03:00:26.593]         ...future.startTime <- base::Sys.time()
  [03:00:26.593]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.593]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.593]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.593]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.593]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.593]         {
  [03:00:26.593]             {
  [03:00:26.593]                 base::local({
  [03:00:26.593]                   has_future <- base::requireNamespace("future", 
  [03:00:26.593]                     quietly = TRUE)
  [03:00:26.593]                   version <- if (has_future) 
  [03:00:26.593]                     utils::packageVersion("future")
  [03:00:26.593]                   else NULL
  [03:00:26.593]                   if (!has_future || version < "1.8.0") {
  [03:00:26.593]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.593]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.593]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.593]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.593]                         "release", "version")], collapse = " "), 
  [03:00:26.593]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.593]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.593]                       info)
  [03:00:26.593]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.593]                     if (!has_future) {
  [03:00:26.593]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.593]                         info)
  [03:00:26.593]                     }
  [03:00:26.593]                     else {
  [03:00:26.593]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.593]                         info, version)
  [03:00:26.593]                     }
  [03:00:26.593]                     base::stop(msg)
  [03:00:26.593]                   }
  [03:00:26.593]                 })
  [03:00:26.593]             }
  [03:00:26.593]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.593]         }
  [03:00:26.593]     }
  [03:00:26.593]     if (base::is.na(NA)) {
  [03:00:26.593]     }
  [03:00:26.593]     else {
  [03:00:26.593]         if (NA) {
  [03:00:26.593]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.593]                 open = "w")
  [03:00:26.593]         }
  [03:00:26.593]         else {
  [03:00:26.593]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.593]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.593]         }
  [03:00:26.593]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.593]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.593]             base::sink(type = "output", split = FALSE)
  [03:00:26.593]             base::close(...future.stdout)
  [03:00:26.593]         }, add = TRUE)
  [03:00:26.593]     }
  [03:00:26.593]     ...future.frame <- base::sys.nframe()
  [03:00:26.593]     ...future.conditions <- base::list()
  [03:00:26.593]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.593]     ...future.result <- base::tryCatch({
  [03:00:26.593]         base::withCallingHandlers({
  [03:00:26.593]             ...future.value <- base::withVisible(base::local({
  [03:00:26.593]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.593]             }))
  [03:00:26.593]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.593]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.593]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.593]                 version = "1.8")
  [03:00:26.593]         }, condition = base::local({
  [03:00:26.593]             c <- base::c
  [03:00:26.593]             inherits <- base::inherits
  [03:00:26.593]             invokeRestart <- base::invokeRestart
  [03:00:26.593]             length <- base::length
  [03:00:26.593]             list <- base::list
  [03:00:26.593]             seq.int <- base::seq.int
  [03:00:26.593]             signalCondition <- base::signalCondition
  [03:00:26.593]             sys.calls <- base::sys.calls
  [03:00:26.593]             Sys.time <- base::Sys.time
  [03:00:26.593]             `[[` <- base::`[[`
  [03:00:26.593]             `+` <- base::`+`
  [03:00:26.593]             `<<-` <- base::`<<-`
  [03:00:26.593]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.593]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.593]                   3L)]
  [03:00:26.593]             }
  [03:00:26.593]             function(cond) {
  [03:00:26.593]                 if (inherits(cond, "error")) {
  [03:00:26.593]                   sessionInformation <- function() {
  [03:00:26.593]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.593]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.593]                       search = base::search(), system = base::Sys.info())
  [03:00:26.593]                   }
  [03:00:26.593]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.593]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.593]                     cond$call), session = sessionInformation(), 
  [03:00:26.593]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.593]                   signalCondition(cond)
  [03:00:26.593]                 }
  [03:00:26.593]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.593]                 ))) {
  [03:00:26.593]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.593]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.593]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.593]                   if (!signal) {
  [03:00:26.593]                     muffleCondition <- function (cond) 
  [03:00:26.593]                     {
  [03:00:26.593]                       inherits <- base::inherits
  [03:00:26.593]                       invokeRestart <- base::invokeRestart
  [03:00:26.593]                       muffled <- FALSE
  [03:00:26.593]                       if (inherits(cond, "message")) {
  [03:00:26.593]                         invokeRestart("muffleMessage")
  [03:00:26.593]                         muffled <- TRUE
  [03:00:26.593]                       }
  [03:00:26.593]                       else if (inherits(cond, "warning")) {
  [03:00:26.593]                         invokeRestart("muffleWarning")
  [03:00:26.593]                         muffled <- TRUE
  [03:00:26.593]                       }
  [03:00:26.593]                       else if (inherits(cond, "condition")) {
  [03:00:26.593]                         computeRestarts <- base::computeRestarts
  [03:00:26.593]                         grepl <- base::grepl
  [03:00:26.593]                         is.null <- base::is.null
  [03:00:26.593]                         restarts <- computeRestarts(cond)
  [03:00:26.593]                         for (restart in restarts) {
  [03:00:26.593]                           name <- restart$name
  [03:00:26.593]                           if (is.null(name)) 
  [03:00:26.593]                             next
  [03:00:26.593]                           if (!grepl("^muffle", name)) 
  [03:00:26.593]                             next
  [03:00:26.593]                           invokeRestart(restart)
  [03:00:26.593]                           muffled <- TRUE
  [03:00:26.593]                           break
  [03:00:26.593]                         }
  [03:00:26.593]                       }
  [03:00:26.593]                       invisible(muffled)
  [03:00:26.593]                     }
  [03:00:26.593]                     muffleCondition(cond)
  [03:00:26.593]                   }
  [03:00:26.593]                 }
  [03:00:26.593]             }
  [03:00:26.593]         }))
  [03:00:26.593]     }, error = function(ex) {
  [03:00:26.593]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.593]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.593]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.593]     }, finally = {
  [03:00:26.593]         {
  [03:00:26.593]             NULL
  [03:00:26.593]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.593]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.593]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.593]                 label = NULL, ...) 
  [03:00:26.593]             {
  [03:00:26.593]                 if (substitute) 
  [03:00:26.593]                   expr <- substitute(expr)
  [03:00:26.593]                 local <- as.logical(local)
  [03:00:26.593]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.593]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.593]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.593]                   label = label, ...)
  [03:00:26.593]                 if (!future$lazy) 
  [03:00:26.593]                   future <- run(future)
  [03:00:26.593]                 invisible(future)
  [03:00:26.593]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.593]         }
  [03:00:26.593]         base::options(...future.oldOptions)
  [03:00:26.593]     })
  [03:00:26.593]     Sys.time
  [03:00:26.593]     if (base::is.na(NA)) {
  [03:00:26.593]     }
  [03:00:26.593]     else {
  [03:00:26.593]         base::sink(type = "output", split = FALSE)
  [03:00:26.593]         if (NA) {
  [03:00:26.593]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.593]         }
  [03:00:26.593]         else {
  [03:00:26.593]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.593]         }
  [03:00:26.593]         base::close(...future.stdout)
  [03:00:26.593]         ...future.stdout <- NULL
  [03:00:26.593]     }
  [03:00:26.593]     ...future.result$conditions <- ...future.conditions
  [03:00:26.593]     ...future.result
  [03:00:26.593] }
  [03:00:26.622] plan(): Setting new future strategy stack:
  [03:00:26.624] List of future strategies:
  [03:00:26.624] 1. sequential:
  [03:00:26.624]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.624]    - tweaked: FALSE
  [03:00:26.624]    - call: NULL
  [03:00:26.641] plan(): nbrOfWorkers() = 1
  [03:00:26.644] plan(): Setting new future strategy stack:
  [03:00:26.647] List of future strategies:
  [03:00:26.647] 1. sequential:
  [03:00:26.647]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.647]    - tweaked: FALSE
  [03:00:26.647]    - call: NULL
  [03:00:26.650] plan(): nbrOfWorkers() = 1
  [03:00:26.653] SequentialFuture started (and completed)
  [03:00:26.669] plan(): Setting new future strategy stack:
  [03:00:26.671] List of future strategies:
  [03:00:26.671] 1. sequential:
  [03:00:26.671]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.671]    - tweaked: FALSE
  [03:00:26.671]    - call: NULL
  [03:00:26.674] plan(): nbrOfWorkers() = 1
  [03:00:26.676] SequentialFuture started (and completed)
  [03:00:26.694] Packages needed by the future expression (n = 0): <none>
  [03:00:26.696] Packages needed by future strategies (n = 0): <none>
  [03:00:26.704] {
  [03:00:26.704]     {
  [03:00:26.704]         ...future.startTime <- base::Sys.time()
  [03:00:26.704]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.704]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.704]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.704]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.704]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.704]         {
  [03:00:26.704]             {
  [03:00:26.704]                 base::local({
  [03:00:26.704]                   has_future <- base::requireNamespace("future", 
  [03:00:26.704]                     quietly = TRUE)
  [03:00:26.704]                   version <- if (has_future) 
  [03:00:26.704]                     utils::packageVersion("future")
  [03:00:26.704]                   else NULL
  [03:00:26.704]                   if (!has_future || version < "1.8.0") {
  [03:00:26.704]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.704]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.704]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.704]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.704]                         "release", "version")], collapse = " "), 
  [03:00:26.704]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.704]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.704]                       info)
  [03:00:26.704]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.704]                     if (!has_future) {
  [03:00:26.704]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.704]                         info)
  [03:00:26.704]                     }
  [03:00:26.704]                     else {
  [03:00:26.704]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.704]                         info, version)
  [03:00:26.704]                     }
  [03:00:26.704]                     base::stop(msg)
  [03:00:26.704]                   }
  [03:00:26.704]                 })
  [03:00:26.704]             }
  [03:00:26.704]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.704]         }
  [03:00:26.704]     }
  [03:00:26.704]     if (base::is.na(NA)) {
  [03:00:26.704]     }
  [03:00:26.704]     else {
  [03:00:26.704]         if (NA) {
  [03:00:26.704]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.704]                 open = "w")
  [03:00:26.704]         }
  [03:00:26.704]         else {
  [03:00:26.704]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.704]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.704]         }
  [03:00:26.704]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.704]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.704]             base::sink(type = "output", split = FALSE)
  [03:00:26.704]             base::close(...future.stdout)
  [03:00:26.704]         }, add = TRUE)
  [03:00:26.704]     }
  [03:00:26.704]     ...future.frame <- base::sys.nframe()
  [03:00:26.704]     ...future.conditions <- base::list()
  [03:00:26.704]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.704]     ...future.result <- base::tryCatch({
  [03:00:26.704]         base::withCallingHandlers({
  [03:00:26.704]             ...future.value <- base::withVisible(base::local({
  [03:00:26.704]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.704]             }))
  [03:00:26.704]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.704]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.704]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.704]                 version = "1.8")
  [03:00:26.704]         }, condition = base::local({
  [03:00:26.704]             c <- base::c
  [03:00:26.704]             inherits <- base::inherits
  [03:00:26.704]             invokeRestart <- base::invokeRestart
  [03:00:26.704]             length <- base::length
  [03:00:26.704]             list <- base::list
  [03:00:26.704]             seq.int <- base::seq.int
  [03:00:26.704]             signalCondition <- base::signalCondition
  [03:00:26.704]             sys.calls <- base::sys.calls
  [03:00:26.704]             Sys.time <- base::Sys.time
  [03:00:26.704]             `[[` <- base::`[[`
  [03:00:26.704]             `+` <- base::`+`
  [03:00:26.704]             `<<-` <- base::`<<-`
  [03:00:26.704]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.704]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.704]                   3L)]
  [03:00:26.704]             }
  [03:00:26.704]             function(cond) {
  [03:00:26.704]                 if (inherits(cond, "error")) {
  [03:00:26.704]                   sessionInformation <- function() {
  [03:00:26.704]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.704]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.704]                       search = base::search(), system = base::Sys.info())
  [03:00:26.704]                   }
  [03:00:26.704]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.704]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.704]                     cond$call), session = sessionInformation(), 
  [03:00:26.704]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.704]                   signalCondition(cond)
  [03:00:26.704]                 }
  [03:00:26.704]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.704]                 ))) {
  [03:00:26.704]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.704]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.704]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.704]                   if (!signal) {
  [03:00:26.704]                     muffleCondition <- function (cond) 
  [03:00:26.704]                     {
  [03:00:26.704]                       inherits <- base::inherits
  [03:00:26.704]                       invokeRestart <- base::invokeRestart
  [03:00:26.704]                       muffled <- FALSE
  [03:00:26.704]                       if (inherits(cond, "message")) {
  [03:00:26.704]                         invokeRestart("muffleMessage")
  [03:00:26.704]                         muffled <- TRUE
  [03:00:26.704]                       }
  [03:00:26.704]                       else if (inherits(cond, "warning")) {
  [03:00:26.704]                         invokeRestart("muffleWarning")
  [03:00:26.704]                         muffled <- TRUE
  [03:00:26.704]                       }
  [03:00:26.704]                       else if (inherits(cond, "condition")) {
  [03:00:26.704]                         computeRestarts <- base::computeRestarts
  [03:00:26.704]                         grepl <- base::grepl
  [03:00:26.704]                         is.null <- base::is.null
  [03:00:26.704]                         restarts <- computeRestarts(cond)
  [03:00:26.704]                         for (restart in restarts) {
  [03:00:26.704]                           name <- restart$name
  [03:00:26.704]                           if (is.null(name)) 
  [03:00:26.704]                             next
  [03:00:26.704]                           if (!grepl("^muffle", name)) 
  [03:00:26.704]                             next
  [03:00:26.704]                           invokeRestart(restart)
  [03:00:26.704]                           muffled <- TRUE
  [03:00:26.704]                           break
  [03:00:26.704]                         }
  [03:00:26.704]                       }
  [03:00:26.704]                       invisible(muffled)
  [03:00:26.704]                     }
  [03:00:26.704]                     muffleCondition(cond)
  [03:00:26.704]                   }
  [03:00:26.704]                 }
  [03:00:26.704]             }
  [03:00:26.704]         }))
  [03:00:26.704]     }, error = function(ex) {
  [03:00:26.704]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.704]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.704]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.704]     }, finally = {
  [03:00:26.704]         {
  [03:00:26.704]             NULL
  [03:00:26.704]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.704]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.704]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.704]                 label = NULL, ...) 
  [03:00:26.704]             {
  [03:00:26.704]                 if (substitute) 
  [03:00:26.704]                   expr <- substitute(expr)
  [03:00:26.704]                 local <- as.logical(local)
  [03:00:26.704]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.704]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.704]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.704]                   label = label, ...)
  [03:00:26.704]                 if (!future$lazy) 
  [03:00:26.704]                   future <- run(future)
  [03:00:26.704]                 invisible(future)
  [03:00:26.704]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.704]         }
  [03:00:26.704]         base::options(...future.oldOptions)
  [03:00:26.704]     })
  [03:00:26.704]     Sys.time
  [03:00:26.704]     if (base::is.na(NA)) {
  [03:00:26.704]     }
  [03:00:26.704]     else {
  [03:00:26.704]         base::sink(type = "output", split = FALSE)
  [03:00:26.704]         if (NA) {
  [03:00:26.704]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.704]         }
  [03:00:26.704]         else {
  [03:00:26.704]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.704]         }
  [03:00:26.704]         base::close(...future.stdout)
  [03:00:26.704]         ...future.stdout <- NULL
  [03:00:26.704]     }
  [03:00:26.704]     ...future.result$conditions <- ...future.conditions
  [03:00:26.704]     ...future.result
  [03:00:26.704] }
  [03:00:26.713] plan(): Setting new future strategy stack:
  [03:00:26.715] List of future strategies:
  [03:00:26.715] 1. sequential:
  [03:00:26.715]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.715]    - tweaked: FALSE
  [03:00:26.715]    - call: NULL
  [03:00:26.718] plan(): nbrOfWorkers() = 1
  [03:00:26.721] plan(): Setting new future strategy stack:
  [03:00:26.723] List of future strategies:
  [03:00:26.723] 1. sequential:
  [03:00:26.723]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.723]    - tweaked: FALSE
  [03:00:26.723]    - call: NULL
  [03:00:26.726] plan(): nbrOfWorkers() = 1
  [03:00:26.732] SequentialFuture started (and completed)
  [03:00:26.735] plan(): Setting new future strategy stack:
  [03:00:26.737] List of future strategies:
  [03:00:26.737] 1. sequential:
  [03:00:26.737]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.737]    - tweaked: FALSE
  [03:00:26.737]    - call: NULL
  [03:00:26.740] plan(): nbrOfWorkers() = 1
  [03:00:26.742] SequentialFuture started (and completed)
  [03:00:26.747] Packages needed by the future expression (n = 0): <none>
  [03:00:26.749] Packages needed by future strategies (n = 0): <none>
  [03:00:26.757] {
  [03:00:26.757]     {
  [03:00:26.757]         ...future.startTime <- base::Sys.time()
  [03:00:26.757]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.757]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.757]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.757]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.757]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.757]         {
  [03:00:26.757]             {
  [03:00:26.757]                 base::local({
  [03:00:26.757]                   has_future <- base::requireNamespace("future", 
  [03:00:26.757]                     quietly = TRUE)
  [03:00:26.757]                   version <- if (has_future) 
  [03:00:26.757]                     utils::packageVersion("future")
  [03:00:26.757]                   else NULL
  [03:00:26.757]                   if (!has_future || version < "1.8.0") {
  [03:00:26.757]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.757]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.757]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.757]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.757]                         "release", "version")], collapse = " "), 
  [03:00:26.757]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.757]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.757]                       info)
  [03:00:26.757]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.757]                     if (!has_future) {
  [03:00:26.757]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.757]                         info)
  [03:00:26.757]                     }
  [03:00:26.757]                     else {
  [03:00:26.757]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.757]                         info, version)
  [03:00:26.757]                     }
  [03:00:26.757]                     base::stop(msg)
  [03:00:26.757]                   }
  [03:00:26.757]                 })
  [03:00:26.757]             }
  [03:00:26.757]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.757]         }
  [03:00:26.757]     }
  [03:00:26.757]     if (base::is.na(NA)) {
  [03:00:26.757]     }
  [03:00:26.757]     else {
  [03:00:26.757]         if (NA) {
  [03:00:26.757]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.757]                 open = "w")
  [03:00:26.757]         }
  [03:00:26.757]         else {
  [03:00:26.757]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.757]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.757]         }
  [03:00:26.757]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.757]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.757]             base::sink(type = "output", split = FALSE)
  [03:00:26.757]             base::close(...future.stdout)
  [03:00:26.757]         }, add = TRUE)
  [03:00:26.757]     }
  [03:00:26.757]     ...future.frame <- base::sys.nframe()
  [03:00:26.757]     ...future.conditions <- base::list()
  [03:00:26.757]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.757]     ...future.result <- base::tryCatch({
  [03:00:26.757]         base::withCallingHandlers({
  [03:00:26.757]             ...future.value <- base::withVisible(base::local({
  [03:00:26.757]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.757]             }))
  [03:00:26.757]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.757]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.757]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.757]                 version = "1.8")
  [03:00:26.757]         }, condition = base::local({
  [03:00:26.757]             c <- base::c
  [03:00:26.757]             inherits <- base::inherits
  [03:00:26.757]             invokeRestart <- base::invokeRestart
  [03:00:26.757]             length <- base::length
  [03:00:26.757]             list <- base::list
  [03:00:26.757]             seq.int <- base::seq.int
  [03:00:26.757]             signalCondition <- base::signalCondition
  [03:00:26.757]             sys.calls <- base::sys.calls
  [03:00:26.757]             Sys.time <- base::Sys.time
  [03:00:26.757]             `[[` <- base::`[[`
  [03:00:26.757]             `+` <- base::`+`
  [03:00:26.757]             `<<-` <- base::`<<-`
  [03:00:26.757]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.757]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.757]                   3L)]
  [03:00:26.757]             }
  [03:00:26.757]             function(cond) {
  [03:00:26.757]                 if (inherits(cond, "error")) {
  [03:00:26.757]                   sessionInformation <- function() {
  [03:00:26.757]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.757]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.757]                       search = base::search(), system = base::Sys.info())
  [03:00:26.757]                   }
  [03:00:26.757]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.757]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.757]                     cond$call), session = sessionInformation(), 
  [03:00:26.757]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.757]                   signalCondition(cond)
  [03:00:26.757]                 }
  [03:00:26.757]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.757]                 ))) {
  [03:00:26.757]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.757]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.757]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.757]                   if (!signal) {
  [03:00:26.757]                     muffleCondition <- function (cond) 
  [03:00:26.757]                     {
  [03:00:26.757]                       inherits <- base::inherits
  [03:00:26.757]                       invokeRestart <- base::invokeRestart
  [03:00:26.757]                       muffled <- FALSE
  [03:00:26.757]                       if (inherits(cond, "message")) {
  [03:00:26.757]                         invokeRestart("muffleMessage")
  [03:00:26.757]                         muffled <- TRUE
  [03:00:26.757]                       }
  [03:00:26.757]                       else if (inherits(cond, "warning")) {
  [03:00:26.757]                         invokeRestart("muffleWarning")
  [03:00:26.757]                         muffled <- TRUE
  [03:00:26.757]                       }
  [03:00:26.757]                       else if (inherits(cond, "condition")) {
  [03:00:26.757]                         computeRestarts <- base::computeRestarts
  [03:00:26.757]                         grepl <- base::grepl
  [03:00:26.757]                         is.null <- base::is.null
  [03:00:26.757]                         restarts <- computeRestarts(cond)
  [03:00:26.757]                         for (restart in restarts) {
  [03:00:26.757]                           name <- restart$name
  [03:00:26.757]                           if (is.null(name)) 
  [03:00:26.757]                             next
  [03:00:26.757]                           if (!grepl("^muffle", name)) 
  [03:00:26.757]                             next
  [03:00:26.757]                           invokeRestart(restart)
  [03:00:26.757]                           muffled <- TRUE
  [03:00:26.757]                           break
  [03:00:26.757]                         }
  [03:00:26.757]                       }
  [03:00:26.757]                       invisible(muffled)
  [03:00:26.757]                     }
  [03:00:26.757]                     muffleCondition(cond)
  [03:00:26.757]                   }
  [03:00:26.757]                 }
  [03:00:26.757]             }
  [03:00:26.757]         }))
  [03:00:26.757]     }, error = function(ex) {
  [03:00:26.757]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.757]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.757]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.757]     }, finally = {
  [03:00:26.757]         {
  [03:00:26.757]             NULL
  [03:00:26.757]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.757]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.757]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.757]                 label = NULL, ...) 
  [03:00:26.757]             {
  [03:00:26.757]                 if (substitute) 
  [03:00:26.757]                   expr <- substitute(expr)
  [03:00:26.757]                 local <- as.logical(local)
  [03:00:26.757]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.757]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.757]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.757]                   label = label, ...)
  [03:00:26.757]                 if (!future$lazy) 
  [03:00:26.757]                   future <- run(future)
  [03:00:26.757]                 invisible(future)
  [03:00:26.757]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.757]         }
  [03:00:26.757]         base::options(...future.oldOptions)
  [03:00:26.757]     })
  [03:00:26.757]     Sys.time
  [03:00:26.757]     if (base::is.na(NA)) {
  [03:00:26.757]     }
  [03:00:26.757]     else {
  [03:00:26.757]         base::sink(type = "output", split = FALSE)
  [03:00:26.757]         if (NA) {
  [03:00:26.757]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.757]         }
  [03:00:26.757]         else {
  [03:00:26.757]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.757]         }
  [03:00:26.757]         base::close(...future.stdout)
  [03:00:26.757]         ...future.stdout <- NULL
  [03:00:26.757]     }
  [03:00:26.757]     ...future.result$conditions <- ...future.conditions
  [03:00:26.757]     ...future.result
  [03:00:26.757] }
  [03:00:26.766] plan(): Setting new future strategy stack:
  [03:00:26.768] List of future strategies:
  [03:00:26.768] 1. sequential:
  [03:00:26.768]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.768]    - tweaked: FALSE
  [03:00:26.768]    - call: NULL
  [03:00:26.771] plan(): nbrOfWorkers() = 1
  [03:00:26.773] plan(): Setting new future strategy stack:
  [03:00:26.775] List of future strategies:
  [03:00:26.775] 1. sequential:
  [03:00:26.775]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.775]    - tweaked: FALSE
  [03:00:26.775]    - call: NULL
  [03:00:26.778] plan(): nbrOfWorkers() = 1
  [03:00:26.780] SequentialFuture started (and completed)
  [03:00:26.783] plan(): Setting new future strategy stack:
  [03:00:26.784] List of future strategies:
  [03:00:26.784] 1. sequential:
  [03:00:26.784]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.784]    - tweaked: FALSE
  [03:00:26.784]    - call: NULL
  [03:00:26.787] plan(): nbrOfWorkers() = 1
  [03:00:26.789] SequentialFuture started (and completed)
  [03:00:26.793] Packages needed by the future expression (n = 0): <none>
  [03:00:26.795] Packages needed by future strategies (n = 0): <none>
  [03:00:26.802] {
  [03:00:26.802]     {
  [03:00:26.802]         ...future.startTime <- base::Sys.time()
  [03:00:26.802]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.802]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.802]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.802]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.802]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.802]         {
  [03:00:26.802]             {
  [03:00:26.802]                 base::local({
  [03:00:26.802]                   has_future <- base::requireNamespace("future", 
  [03:00:26.802]                     quietly = TRUE)
  [03:00:26.802]                   version <- if (has_future) 
  [03:00:26.802]                     utils::packageVersion("future")
  [03:00:26.802]                   else NULL
  [03:00:26.802]                   if (!has_future || version < "1.8.0") {
  [03:00:26.802]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.802]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.802]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.802]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.802]                         "release", "version")], collapse = " "), 
  [03:00:26.802]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.802]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.802]                       info)
  [03:00:26.802]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.802]                     if (!has_future) {
  [03:00:26.802]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.802]                         info)
  [03:00:26.802]                     }
  [03:00:26.802]                     else {
  [03:00:26.802]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.802]                         info, version)
  [03:00:26.802]                     }
  [03:00:26.802]                     base::stop(msg)
  [03:00:26.802]                   }
  [03:00:26.802]                 })
  [03:00:26.802]             }
  [03:00:26.802]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.802]         }
  [03:00:26.802]     }
  [03:00:26.802]     if (base::is.na(NA)) {
  [03:00:26.802]     }
  [03:00:26.802]     else {
  [03:00:26.802]         if (NA) {
  [03:00:26.802]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.802]                 open = "w")
  [03:00:26.802]         }
  [03:00:26.802]         else {
  [03:00:26.802]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.802]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.802]         }
  [03:00:26.802]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.802]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.802]             base::sink(type = "output", split = FALSE)
  [03:00:26.802]             base::close(...future.stdout)
  [03:00:26.802]         }, add = TRUE)
  [03:00:26.802]     }
  [03:00:26.802]     ...future.frame <- base::sys.nframe()
  [03:00:26.802]     ...future.conditions <- base::list()
  [03:00:26.802]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.802]     ...future.result <- base::tryCatch({
  [03:00:26.802]         base::withCallingHandlers({
  [03:00:26.802]             ...future.value <- base::withVisible(base::local({
  [03:00:26.802]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.802]             }))
  [03:00:26.802]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.802]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.802]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.802]                 version = "1.8")
  [03:00:26.802]         }, condition = base::local({
  [03:00:26.802]             c <- base::c
  [03:00:26.802]             inherits <- base::inherits
  [03:00:26.802]             invokeRestart <- base::invokeRestart
  [03:00:26.802]             length <- base::length
  [03:00:26.802]             list <- base::list
  [03:00:26.802]             seq.int <- base::seq.int
  [03:00:26.802]             signalCondition <- base::signalCondition
  [03:00:26.802]             sys.calls <- base::sys.calls
  [03:00:26.802]             Sys.time <- base::Sys.time
  [03:00:26.802]             `[[` <- base::`[[`
  [03:00:26.802]             `+` <- base::`+`
  [03:00:26.802]             `<<-` <- base::`<<-`
  [03:00:26.802]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.802]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.802]                   3L)]
  [03:00:26.802]             }
  [03:00:26.802]             function(cond) {
  [03:00:26.802]                 if (inherits(cond, "error")) {
  [03:00:26.802]                   sessionInformation <- function() {
  [03:00:26.802]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.802]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.802]                       search = base::search(), system = base::Sys.info())
  [03:00:26.802]                   }
  [03:00:26.802]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.802]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.802]                     cond$call), session = sessionInformation(), 
  [03:00:26.802]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.802]                   signalCondition(cond)
  [03:00:26.802]                 }
  [03:00:26.802]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.802]                 ))) {
  [03:00:26.802]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.802]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.802]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.802]                   if (!signal) {
  [03:00:26.802]                     muffleCondition <- function (cond) 
  [03:00:26.802]                     {
  [03:00:26.802]                       inherits <- base::inherits
  [03:00:26.802]                       invokeRestart <- base::invokeRestart
  [03:00:26.802]                       muffled <- FALSE
  [03:00:26.802]                       if (inherits(cond, "message")) {
  [03:00:26.802]                         invokeRestart("muffleMessage")
  [03:00:26.802]                         muffled <- TRUE
  [03:00:26.802]                       }
  [03:00:26.802]                       else if (inherits(cond, "warning")) {
  [03:00:26.802]                         invokeRestart("muffleWarning")
  [03:00:26.802]                         muffled <- TRUE
  [03:00:26.802]                       }
  [03:00:26.802]                       else if (inherits(cond, "condition")) {
  [03:00:26.802]                         computeRestarts <- base::computeRestarts
  [03:00:26.802]                         grepl <- base::grepl
  [03:00:26.802]                         is.null <- base::is.null
  [03:00:26.802]                         restarts <- computeRestarts(cond)
  [03:00:26.802]                         for (restart in restarts) {
  [03:00:26.802]                           name <- restart$name
  [03:00:26.802]                           if (is.null(name)) 
  [03:00:26.802]                             next
  [03:00:26.802]                           if (!grepl("^muffle", name)) 
  [03:00:26.802]                             next
  [03:00:26.802]                           invokeRestart(restart)
  [03:00:26.802]                           muffled <- TRUE
  [03:00:26.802]                           break
  [03:00:26.802]                         }
  [03:00:26.802]                       }
  [03:00:26.802]                       invisible(muffled)
  [03:00:26.802]                     }
  [03:00:26.802]                     muffleCondition(cond)
  [03:00:26.802]                   }
  [03:00:26.802]                 }
  [03:00:26.802]             }
  [03:00:26.802]         }))
  [03:00:26.802]     }, error = function(ex) {
  [03:00:26.802]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.802]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.802]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.802]     }, finally = {
  [03:00:26.802]         {
  [03:00:26.802]             NULL
  [03:00:26.802]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.802]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.802]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.802]                 label = NULL, ...) 
  [03:00:26.802]             {
  [03:00:26.802]                 if (substitute) 
  [03:00:26.802]                   expr <- substitute(expr)
  [03:00:26.802]                 local <- as.logical(local)
  [03:00:26.802]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.802]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.802]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.802]                   label = label, ...)
  [03:00:26.802]                 if (!future$lazy) 
  [03:00:26.802]                   future <- run(future)
  [03:00:26.802]                 invisible(future)
  [03:00:26.802]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.802]         }
  [03:00:26.802]         base::options(...future.oldOptions)
  [03:00:26.802]     })
  [03:00:26.802]     Sys.time
  [03:00:26.802]     if (base::is.na(NA)) {
  [03:00:26.802]     }
  [03:00:26.802]     else {
  [03:00:26.802]         base::sink(type = "output", split = FALSE)
  [03:00:26.802]         if (NA) {
  [03:00:26.802]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.802]         }
  [03:00:26.802]         else {
  [03:00:26.802]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.802]         }
  [03:00:26.802]         base::close(...future.stdout)
  [03:00:26.802]         ...future.stdout <- NULL
  [03:00:26.802]     }
  [03:00:26.802]     ...future.result$conditions <- ...future.conditions
  [03:00:26.802]     ...future.result
  [03:00:26.802] }
  [03:00:26.810] plan(): Setting new future strategy stack:
  [03:00:26.812] List of future strategies:
  [03:00:26.812] 1. sequential:
  [03:00:26.812]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.812]    - tweaked: FALSE
  [03:00:26.812]    - call: NULL
  [03:00:26.815] plan(): nbrOfWorkers() = 1
  [03:00:26.817] plan(): Setting new future strategy stack:
  [03:00:26.819] List of future strategies:
  [03:00:26.819] 1. sequential:
  [03:00:26.819]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.819]    - tweaked: FALSE
  [03:00:26.819]    - call: NULL
  [03:00:26.821] plan(): nbrOfWorkers() = 1
  [03:00:26.823] SequentialFuture started (and completed)
  [03:00:26.826] plan(): Setting new future strategy stack:
  [03:00:26.827] List of future strategies:
  [03:00:26.827] 1. sequential:
  [03:00:26.827]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.827]    - tweaked: FALSE
  [03:00:26.827]    - call: NULL
  [03:00:26.830] plan(): nbrOfWorkers() = 1
  [03:00:26.831] SequentialFuture started (and completed)
  [03:00:26.835] Packages needed by the future expression (n = 0): <none>
  [03:00:26.837] Packages needed by future strategies (n = 0): <none>
  [03:00:26.845] {
  [03:00:26.845]     {
  [03:00:26.845]         ...future.startTime <- base::Sys.time()
  [03:00:26.845]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.845]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.845]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.845]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.845]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.845]         {
  [03:00:26.845]             {
  [03:00:26.845]                 base::local({
  [03:00:26.845]                   has_future <- base::requireNamespace("future", 
  [03:00:26.845]                     quietly = TRUE)
  [03:00:26.845]                   version <- if (has_future) 
  [03:00:26.845]                     utils::packageVersion("future")
  [03:00:26.845]                   else NULL
  [03:00:26.845]                   if (!has_future || version < "1.8.0") {
  [03:00:26.845]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.845]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.845]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.845]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.845]                         "release", "version")], collapse = " "), 
  [03:00:26.845]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.845]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.845]                       info)
  [03:00:26.845]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.845]                     if (!has_future) {
  [03:00:26.845]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.845]                         info)
  [03:00:26.845]                     }
  [03:00:26.845]                     else {
  [03:00:26.845]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.845]                         info, version)
  [03:00:26.845]                     }
  [03:00:26.845]                     base::stop(msg)
  [03:00:26.845]                   }
  [03:00:26.845]                 })
  [03:00:26.845]             }
  [03:00:26.845]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.845]         }
  [03:00:26.845]     }
  [03:00:26.845]     if (base::is.na(NA)) {
  [03:00:26.845]     }
  [03:00:26.845]     else {
  [03:00:26.845]         if (NA) {
  [03:00:26.845]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.845]                 open = "w")
  [03:00:26.845]         }
  [03:00:26.845]         else {
  [03:00:26.845]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.845]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.845]         }
  [03:00:26.845]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.845]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.845]             base::sink(type = "output", split = FALSE)
  [03:00:26.845]             base::close(...future.stdout)
  [03:00:26.845]         }, add = TRUE)
  [03:00:26.845]     }
  [03:00:26.845]     ...future.frame <- base::sys.nframe()
  [03:00:26.845]     ...future.conditions <- base::list()
  [03:00:26.845]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.845]     ...future.result <- base::tryCatch({
  [03:00:26.845]         base::withCallingHandlers({
  [03:00:26.845]             ...future.value <- base::withVisible(base::local({
  [03:00:26.845]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.845]             }))
  [03:00:26.845]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.845]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.845]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.845]                 version = "1.8")
  [03:00:26.845]         }, condition = base::local({
  [03:00:26.845]             c <- base::c
  [03:00:26.845]             inherits <- base::inherits
  [03:00:26.845]             invokeRestart <- base::invokeRestart
  [03:00:26.845]             length <- base::length
  [03:00:26.845]             list <- base::list
  [03:00:26.845]             seq.int <- base::seq.int
  [03:00:26.845]             signalCondition <- base::signalCondition
  [03:00:26.845]             sys.calls <- base::sys.calls
  [03:00:26.845]             Sys.time <- base::Sys.time
  [03:00:26.845]             `[[` <- base::`[[`
  [03:00:26.845]             `+` <- base::`+`
  [03:00:26.845]             `<<-` <- base::`<<-`
  [03:00:26.845]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.845]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.845]                   3L)]
  [03:00:26.845]             }
  [03:00:26.845]             function(cond) {
  [03:00:26.845]                 if (inherits(cond, "error")) {
  [03:00:26.845]                   sessionInformation <- function() {
  [03:00:26.845]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.845]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.845]                       search = base::search(), system = base::Sys.info())
  [03:00:26.845]                   }
  [03:00:26.845]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.845]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.845]                     cond$call), session = sessionInformation(), 
  [03:00:26.845]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.845]                   signalCondition(cond)
  [03:00:26.845]                 }
  [03:00:26.845]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.845]                 ))) {
  [03:00:26.845]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.845]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.845]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.845]                   if (!signal) {
  [03:00:26.845]                     muffleCondition <- function (cond) 
  [03:00:26.845]                     {
  [03:00:26.845]                       inherits <- base::inherits
  [03:00:26.845]                       invokeRestart <- base::invokeRestart
  [03:00:26.845]                       muffled <- FALSE
  [03:00:26.845]                       if (inherits(cond, "message")) {
  [03:00:26.845]                         invokeRestart("muffleMessage")
  [03:00:26.845]                         muffled <- TRUE
  [03:00:26.845]                       }
  [03:00:26.845]                       else if (inherits(cond, "warning")) {
  [03:00:26.845]                         invokeRestart("muffleWarning")
  [03:00:26.845]                         muffled <- TRUE
  [03:00:26.845]                       }
  [03:00:26.845]                       else if (inherits(cond, "condition")) {
  [03:00:26.845]                         computeRestarts <- base::computeRestarts
  [03:00:26.845]                         grepl <- base::grepl
  [03:00:26.845]                         is.null <- base::is.null
  [03:00:26.845]                         restarts <- computeRestarts(cond)
  [03:00:26.845]                         for (restart in restarts) {
  [03:00:26.845]                           name <- restart$name
  [03:00:26.845]                           if (is.null(name)) 
  [03:00:26.845]                             next
  [03:00:26.845]                           if (!grepl("^muffle", name)) 
  [03:00:26.845]                             next
  [03:00:26.845]                           invokeRestart(restart)
  [03:00:26.845]                           muffled <- TRUE
  [03:00:26.845]                           break
  [03:00:26.845]                         }
  [03:00:26.845]                       }
  [03:00:26.845]                       invisible(muffled)
  [03:00:26.845]                     }
  [03:00:26.845]                     muffleCondition(cond)
  [03:00:26.845]                   }
  [03:00:26.845]                 }
  [03:00:26.845]             }
  [03:00:26.845]         }))
  [03:00:26.845]     }, error = function(ex) {
  [03:00:26.845]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.845]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.845]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.845]     }, finally = {
  [03:00:26.845]         {
  [03:00:26.845]             NULL
  [03:00:26.845]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.845]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.845]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.845]                 label = NULL, ...) 
  [03:00:26.845]             {
  [03:00:26.845]                 if (substitute) 
  [03:00:26.845]                   expr <- substitute(expr)
  [03:00:26.845]                 local <- as.logical(local)
  [03:00:26.845]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.845]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.845]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.845]                   label = label, ...)
  [03:00:26.845]                 if (!future$lazy) 
  [03:00:26.845]                   future <- run(future)
  [03:00:26.845]                 invisible(future)
  [03:00:26.845]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.845]         }
  [03:00:26.845]         base::options(...future.oldOptions)
  [03:00:26.845]     })
  [03:00:26.845]     Sys.time
  [03:00:26.845]     if (base::is.na(NA)) {
  [03:00:26.845]     }
  [03:00:26.845]     else {
  [03:00:26.845]         base::sink(type = "output", split = FALSE)
  [03:00:26.845]         if (NA) {
  [03:00:26.845]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.845]         }
  [03:00:26.845]         else {
  [03:00:26.845]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.845]         }
  [03:00:26.845]         base::close(...future.stdout)
  [03:00:26.845]         ...future.stdout <- NULL
  [03:00:26.845]     }
  [03:00:26.845]     ...future.result$conditions <- ...future.conditions
  [03:00:26.845]     ...future.result
  [03:00:26.845] }
  [03:00:26.863] plan(): Setting new future strategy stack:
  [03:00:26.865] List of future strategies:
  [03:00:26.865] 1. sequential:
  [03:00:26.865]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.865]    - tweaked: FALSE
  [03:00:26.865]    - call: NULL
  [03:00:26.868] plan(): nbrOfWorkers() = 1
  [03:00:26.870] plan(): Setting new future strategy stack:
  [03:00:26.872] List of future strategies:
  [03:00:26.872] 1. sequential:
  [03:00:26.872]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.872]    - tweaked: FALSE
  [03:00:26.872]    - call: NULL
  [03:00:26.875] plan(): nbrOfWorkers() = 1
  [03:00:26.877] SequentialFuture started (and completed)
  [03:00:26.879] plan(): Setting new future strategy stack:
  [03:00:26.881] List of future strategies:
  [03:00:26.881] 1. sequential:
  [03:00:26.881]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.881]    - tweaked: FALSE
  [03:00:26.881]    - call: NULL
  [03:00:26.883] plan(): nbrOfWorkers() = 1
  [03:00:26.885] SequentialFuture started (and completed)
  [03:00:26.889] Packages needed by the future expression (n = 0): <none>
  [03:00:26.891] Packages needed by future strategies (n = 0): <none>
  [03:00:26.900] {
  [03:00:26.900]     {
  [03:00:26.900]         ...future.startTime <- base::Sys.time()
  [03:00:26.900]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.900]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.900]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.900]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.900]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.900]         {
  [03:00:26.900]             {
  [03:00:26.900]                 base::local({
  [03:00:26.900]                   has_future <- base::requireNamespace("future", 
  [03:00:26.900]                     quietly = TRUE)
  [03:00:26.900]                   version <- if (has_future) 
  [03:00:26.900]                     utils::packageVersion("future")
  [03:00:26.900]                   else NULL
  [03:00:26.900]                   if (!has_future || version < "1.8.0") {
  [03:00:26.900]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.900]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.900]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.900]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.900]                         "release", "version")], collapse = " "), 
  [03:00:26.900]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.900]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.900]                       info)
  [03:00:26.900]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.900]                     if (!has_future) {
  [03:00:26.900]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.900]                         info)
  [03:00:26.900]                     }
  [03:00:26.900]                     else {
  [03:00:26.900]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.900]                         info, version)
  [03:00:26.900]                     }
  [03:00:26.900]                     base::stop(msg)
  [03:00:26.900]                   }
  [03:00:26.900]                 })
  [03:00:26.900]             }
  [03:00:26.900]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.900]         }
  [03:00:26.900]     }
  [03:00:26.900]     if (base::is.na(NA)) {
  [03:00:26.900]     }
  [03:00:26.900]     else {
  [03:00:26.900]         if (NA) {
  [03:00:26.900]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.900]                 open = "w")
  [03:00:26.900]         }
  [03:00:26.900]         else {
  [03:00:26.900]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.900]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.900]         }
  [03:00:26.900]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.900]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.900]             base::sink(type = "output", split = FALSE)
  [03:00:26.900]             base::close(...future.stdout)
  [03:00:26.900]         }, add = TRUE)
  [03:00:26.900]     }
  [03:00:26.900]     ...future.frame <- base::sys.nframe()
  [03:00:26.900]     ...future.conditions <- base::list()
  [03:00:26.900]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.900]     ...future.result <- base::tryCatch({
  [03:00:26.900]         base::withCallingHandlers({
  [03:00:26.900]             ...future.value <- base::withVisible(base::local({
  [03:00:26.900]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.900]             }))
  [03:00:26.900]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.900]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.900]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.900]                 version = "1.8")
  [03:00:26.900]         }, condition = base::local({
  [03:00:26.900]             c <- base::c
  [03:00:26.900]             inherits <- base::inherits
  [03:00:26.900]             invokeRestart <- base::invokeRestart
  [03:00:26.900]             length <- base::length
  [03:00:26.900]             list <- base::list
  [03:00:26.900]             seq.int <- base::seq.int
  [03:00:26.900]             signalCondition <- base::signalCondition
  [03:00:26.900]             sys.calls <- base::sys.calls
  [03:00:26.900]             Sys.time <- base::Sys.time
  [03:00:26.900]             `[[` <- base::`[[`
  [03:00:26.900]             `+` <- base::`+`
  [03:00:26.900]             `<<-` <- base::`<<-`
  [03:00:26.900]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.900]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.900]                   3L)]
  [03:00:26.900]             }
  [03:00:26.900]             function(cond) {
  [03:00:26.900]                 if (inherits(cond, "error")) {
  [03:00:26.900]                   sessionInformation <- function() {
  [03:00:26.900]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.900]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.900]                       search = base::search(), system = base::Sys.info())
  [03:00:26.900]                   }
  [03:00:26.900]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.900]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.900]                     cond$call), session = sessionInformation(), 
  [03:00:26.900]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.900]                   signalCondition(cond)
  [03:00:26.900]                 }
  [03:00:26.900]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.900]                 ))) {
  [03:00:26.900]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.900]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.900]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.900]                   if (!signal) {
  [03:00:26.900]                     muffleCondition <- function (cond) 
  [03:00:26.900]                     {
  [03:00:26.900]                       inherits <- base::inherits
  [03:00:26.900]                       invokeRestart <- base::invokeRestart
  [03:00:26.900]                       muffled <- FALSE
  [03:00:26.900]                       if (inherits(cond, "message")) {
  [03:00:26.900]                         invokeRestart("muffleMessage")
  [03:00:26.900]                         muffled <- TRUE
  [03:00:26.900]                       }
  [03:00:26.900]                       else if (inherits(cond, "warning")) {
  [03:00:26.900]                         invokeRestart("muffleWarning")
  [03:00:26.900]                         muffled <- TRUE
  [03:00:26.900]                       }
  [03:00:26.900]                       else if (inherits(cond, "condition")) {
  [03:00:26.900]                         computeRestarts <- base::computeRestarts
  [03:00:26.900]                         grepl <- base::grepl
  [03:00:26.900]                         is.null <- base::is.null
  [03:00:26.900]                         restarts <- computeRestarts(cond)
  [03:00:26.900]                         for (restart in restarts) {
  [03:00:26.900]                           name <- restart$name
  [03:00:26.900]                           if (is.null(name)) 
  [03:00:26.900]                             next
  [03:00:26.900]                           if (!grepl("^muffle", name)) 
  [03:00:26.900]                             next
  [03:00:26.900]                           invokeRestart(restart)
  [03:00:26.900]                           muffled <- TRUE
  [03:00:26.900]                           break
  [03:00:26.900]                         }
  [03:00:26.900]                       }
  [03:00:26.900]                       invisible(muffled)
  [03:00:26.900]                     }
  [03:00:26.900]                     muffleCondition(cond)
  [03:00:26.900]                   }
  [03:00:26.900]                 }
  [03:00:26.900]             }
  [03:00:26.900]         }))
  [03:00:26.900]     }, error = function(ex) {
  [03:00:26.900]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.900]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.900]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.900]     }, finally = {
  [03:00:26.900]         {
  [03:00:26.900]             NULL
  [03:00:26.900]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.900]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.900]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.900]                 label = NULL, ...) 
  [03:00:26.900]             {
  [03:00:26.900]                 if (substitute) 
  [03:00:26.900]                   expr <- substitute(expr)
  [03:00:26.900]                 local <- as.logical(local)
  [03:00:26.900]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.900]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.900]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.900]                   label = label, ...)
  [03:00:26.900]                 if (!future$lazy) 
  [03:00:26.900]                   future <- run(future)
  [03:00:26.900]                 invisible(future)
  [03:00:26.900]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.900]         }
  [03:00:26.900]         base::options(...future.oldOptions)
  [03:00:26.900]     })
  [03:00:26.900]     Sys.time
  [03:00:26.900]     if (base::is.na(NA)) {
  [03:00:26.900]     }
  [03:00:26.900]     else {
  [03:00:26.900]         base::sink(type = "output", split = FALSE)
  [03:00:26.900]         if (NA) {
  [03:00:26.900]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.900]         }
  [03:00:26.900]         else {
  [03:00:26.900]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.900]         }
  [03:00:26.900]         base::close(...future.stdout)
  [03:00:26.900]         ...future.stdout <- NULL
  [03:00:26.900]     }
  [03:00:26.900]     ...future.result$conditions <- ...future.conditions
  [03:00:26.900]     ...future.result
  [03:00:26.900] }
  [03:00:26.908] plan(): Setting new future strategy stack:
  [03:00:26.910] List of future strategies:
  [03:00:26.910] 1. sequential:
  [03:00:26.910]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.910]    - tweaked: FALSE
  [03:00:26.910]    - call: NULL
  [03:00:26.912] plan(): nbrOfWorkers() = 1
  [03:00:26.915] plan(): Setting new future strategy stack:
  [03:00:26.916] List of future strategies:
  [03:00:26.916] 1. sequential:
  [03:00:26.916]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.916]    - tweaked: FALSE
  [03:00:26.916]    - call: NULL
  [03:00:26.918] plan(): nbrOfWorkers() = 1
  [03:00:26.920] SequentialFuture started (and completed)
  [03:00:26.922] plan(): Setting new future strategy stack:
  [03:00:26.923] List of future strategies:
  [03:00:26.923] 1. sequential:
  [03:00:26.923]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.923]    - tweaked: FALSE
  [03:00:26.923]    - call: NULL
  [03:00:26.926] plan(): nbrOfWorkers() = 1
  [03:00:26.927] SequentialFuture started (and completed)
  [03:00:26.931] Packages needed by the future expression (n = 0): <none>
  [03:00:26.932] Packages needed by future strategies (n = 0): <none>
  [03:00:26.940] {
  [03:00:26.940]     {
  [03:00:26.940]         ...future.startTime <- base::Sys.time()
  [03:00:26.940]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.940]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.940]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.940]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.940]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.940]         {
  [03:00:26.940]             {
  [03:00:26.940]                 base::local({
  [03:00:26.940]                   has_future <- base::requireNamespace("future", 
  [03:00:26.940]                     quietly = TRUE)
  [03:00:26.940]                   version <- if (has_future) 
  [03:00:26.940]                     utils::packageVersion("future")
  [03:00:26.940]                   else NULL
  [03:00:26.940]                   if (!has_future || version < "1.8.0") {
  [03:00:26.940]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.940]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.940]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.940]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.940]                         "release", "version")], collapse = " "), 
  [03:00:26.940]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.940]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.940]                       info)
  [03:00:26.940]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.940]                     if (!has_future) {
  [03:00:26.940]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.940]                         info)
  [03:00:26.940]                     }
  [03:00:26.940]                     else {
  [03:00:26.940]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.940]                         info, version)
  [03:00:26.940]                     }
  [03:00:26.940]                     base::stop(msg)
  [03:00:26.940]                   }
  [03:00:26.940]                 })
  [03:00:26.940]             }
  [03:00:26.940]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.940]         }
  [03:00:26.940]     }
  [03:00:26.940]     if (base::is.na(NA)) {
  [03:00:26.940]     }
  [03:00:26.940]     else {
  [03:00:26.940]         if (NA) {
  [03:00:26.940]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.940]                 open = "w")
  [03:00:26.940]         }
  [03:00:26.940]         else {
  [03:00:26.940]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.940]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.940]         }
  [03:00:26.940]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.940]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.940]             base::sink(type = "output", split = FALSE)
  [03:00:26.940]             base::close(...future.stdout)
  [03:00:26.940]         }, add = TRUE)
  [03:00:26.940]     }
  [03:00:26.940]     ...future.frame <- base::sys.nframe()
  [03:00:26.940]     ...future.conditions <- base::list()
  [03:00:26.940]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.940]     ...future.result <- base::tryCatch({
  [03:00:26.940]         base::withCallingHandlers({
  [03:00:26.940]             ...future.value <- base::withVisible(base::local({
  [03:00:26.940]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.940]             }))
  [03:00:26.940]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.940]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.940]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.940]                 version = "1.8")
  [03:00:26.940]         }, condition = base::local({
  [03:00:26.940]             c <- base::c
  [03:00:26.940]             inherits <- base::inherits
  [03:00:26.940]             invokeRestart <- base::invokeRestart
  [03:00:26.940]             length <- base::length
  [03:00:26.940]             list <- base::list
  [03:00:26.940]             seq.int <- base::seq.int
  [03:00:26.940]             signalCondition <- base::signalCondition
  [03:00:26.940]             sys.calls <- base::sys.calls
  [03:00:26.940]             Sys.time <- base::Sys.time
  [03:00:26.940]             `[[` <- base::`[[`
  [03:00:26.940]             `+` <- base::`+`
  [03:00:26.940]             `<<-` <- base::`<<-`
  [03:00:26.940]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.940]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.940]                   3L)]
  [03:00:26.940]             }
  [03:00:26.940]             function(cond) {
  [03:00:26.940]                 if (inherits(cond, "error")) {
  [03:00:26.940]                   sessionInformation <- function() {
  [03:00:26.940]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.940]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.940]                       search = base::search(), system = base::Sys.info())
  [03:00:26.940]                   }
  [03:00:26.940]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.940]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.940]                     cond$call), session = sessionInformation(), 
  [03:00:26.940]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.940]                   signalCondition(cond)
  [03:00:26.940]                 }
  [03:00:26.940]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.940]                 ))) {
  [03:00:26.940]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.940]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.940]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.940]                   if (!signal) {
  [03:00:26.940]                     muffleCondition <- function (cond) 
  [03:00:26.940]                     {
  [03:00:26.940]                       inherits <- base::inherits
  [03:00:26.940]                       invokeRestart <- base::invokeRestart
  [03:00:26.940]                       muffled <- FALSE
  [03:00:26.940]                       if (inherits(cond, "message")) {
  [03:00:26.940]                         invokeRestart("muffleMessage")
  [03:00:26.940]                         muffled <- TRUE
  [03:00:26.940]                       }
  [03:00:26.940]                       else if (inherits(cond, "warning")) {
  [03:00:26.940]                         invokeRestart("muffleWarning")
  [03:00:26.940]                         muffled <- TRUE
  [03:00:26.940]                       }
  [03:00:26.940]                       else if (inherits(cond, "condition")) {
  [03:00:26.940]                         computeRestarts <- base::computeRestarts
  [03:00:26.940]                         grepl <- base::grepl
  [03:00:26.940]                         is.null <- base::is.null
  [03:00:26.940]                         restarts <- computeRestarts(cond)
  [03:00:26.940]                         for (restart in restarts) {
  [03:00:26.940]                           name <- restart$name
  [03:00:26.940]                           if (is.null(name)) 
  [03:00:26.940]                             next
  [03:00:26.940]                           if (!grepl("^muffle", name)) 
  [03:00:26.940]                             next
  [03:00:26.940]                           invokeRestart(restart)
  [03:00:26.940]                           muffled <- TRUE
  [03:00:26.940]                           break
  [03:00:26.940]                         }
  [03:00:26.940]                       }
  [03:00:26.940]                       invisible(muffled)
  [03:00:26.940]                     }
  [03:00:26.940]                     muffleCondition(cond)
  [03:00:26.940]                   }
  [03:00:26.940]                 }
  [03:00:26.940]             }
  [03:00:26.940]         }))
  [03:00:26.940]     }, error = function(ex) {
  [03:00:26.940]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.940]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.940]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.940]     }, finally = {
  [03:00:26.940]         {
  [03:00:26.940]             NULL
  [03:00:26.940]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.940]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.940]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.940]                 label = NULL, ...) 
  [03:00:26.940]             {
  [03:00:26.940]                 if (substitute) 
  [03:00:26.940]                   expr <- substitute(expr)
  [03:00:26.940]                 local <- as.logical(local)
  [03:00:26.940]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.940]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.940]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.940]                   label = label, ...)
  [03:00:26.940]                 if (!future$lazy) 
  [03:00:26.940]                   future <- run(future)
  [03:00:26.940]                 invisible(future)
  [03:00:26.940]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.940]         }
  [03:00:26.940]         base::options(...future.oldOptions)
  [03:00:26.940]     })
  [03:00:26.940]     Sys.time
  [03:00:26.940]     if (base::is.na(NA)) {
  [03:00:26.940]     }
  [03:00:26.940]     else {
  [03:00:26.940]         base::sink(type = "output", split = FALSE)
  [03:00:26.940]         if (NA) {
  [03:00:26.940]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.940]         }
  [03:00:26.940]         else {
  [03:00:26.940]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.940]         }
  [03:00:26.940]         base::close(...future.stdout)
  [03:00:26.940]         ...future.stdout <- NULL
  [03:00:26.940]     }
  [03:00:26.940]     ...future.result$conditions <- ...future.conditions
  [03:00:26.940]     ...future.result
  [03:00:26.940] }
  [03:00:26.948] plan(): Setting new future strategy stack:
  [03:00:26.949] List of future strategies:
  [03:00:26.949] 1. sequential:
  [03:00:26.949]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.949]    - tweaked: FALSE
  [03:00:26.949]    - call: NULL
  [03:00:26.951] plan(): nbrOfWorkers() = 1
  [03:00:26.953] plan(): Setting new future strategy stack:
  [03:00:26.955] List of future strategies:
  [03:00:26.955] 1. sequential:
  [03:00:26.955]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.955]    - tweaked: FALSE
  [03:00:26.955]    - call: NULL
  [03:00:26.957] plan(): nbrOfWorkers() = 1
  [03:00:26.958] SequentialFuture started (and completed)
  [03:00:26.960] plan(): Setting new future strategy stack:
  [03:00:26.961] List of future strategies:
  [03:00:26.961] 1. sequential:
  [03:00:26.961]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.961]    - tweaked: FALSE
  [03:00:26.961]    - call: NULL
  [03:00:26.963] plan(): nbrOfWorkers() = 1
  [03:00:26.965] SequentialFuture started (and completed)
  [03:00:26.968] Packages needed by the future expression (n = 0): <none>
  [03:00:26.969] Packages needed by future strategies (n = 0): <none>
  [03:00:26.977] {
  [03:00:26.977]     {
  [03:00:26.977]         ...future.startTime <- base::Sys.time()
  [03:00:26.977]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:26.977]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:26.977]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:26.977]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:26.977]             future.resolve.recursive = NULL, width = 80L)
  [03:00:26.977]         {
  [03:00:26.977]             {
  [03:00:26.977]                 base::local({
  [03:00:26.977]                   has_future <- base::requireNamespace("future", 
  [03:00:26.977]                     quietly = TRUE)
  [03:00:26.977]                   version <- if (has_future) 
  [03:00:26.977]                     utils::packageVersion("future")
  [03:00:26.977]                   else NULL
  [03:00:26.977]                   if (!has_future || version < "1.8.0") {
  [03:00:26.977]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:26.977]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:26.977]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:26.977]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:26.977]                         "release", "version")], collapse = " "), 
  [03:00:26.977]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:26.977]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:26.977]                       info)
  [03:00:26.977]                     info <- base::paste(info, collapse = "; ")
  [03:00:26.977]                     if (!has_future) {
  [03:00:26.977]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:26.977]                         info)
  [03:00:26.977]                     }
  [03:00:26.977]                     else {
  [03:00:26.977]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:26.977]                         info, version)
  [03:00:26.977]                     }
  [03:00:26.977]                     base::stop(msg)
  [03:00:26.977]                   }
  [03:00:26.977]                 })
  [03:00:26.977]             }
  [03:00:26.977]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:26.977]         }
  [03:00:26.977]     }
  [03:00:26.977]     if (base::is.na(NA)) {
  [03:00:26.977]     }
  [03:00:26.977]     else {
  [03:00:26.977]         if (NA) {
  [03:00:26.977]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:26.977]                 open = "w")
  [03:00:26.977]         }
  [03:00:26.977]         else {
  [03:00:26.977]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:26.977]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:26.977]         }
  [03:00:26.977]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:26.977]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:26.977]             base::sink(type = "output", split = FALSE)
  [03:00:26.977]             base::close(...future.stdout)
  [03:00:26.977]         }, add = TRUE)
  [03:00:26.977]     }
  [03:00:26.977]     ...future.frame <- base::sys.nframe()
  [03:00:26.977]     ...future.conditions <- base::list()
  [03:00:26.977]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:26.977]     ...future.result <- base::tryCatch({
  [03:00:26.977]         base::withCallingHandlers({
  [03:00:26.977]             ...future.value <- base::withVisible(base::local({
  [03:00:26.977]                 x[[i - 2]] + x[[i - 1]]
  [03:00:26.977]             }))
  [03:00:26.977]             future::FutureResult(value = ...future.value$value, 
  [03:00:26.977]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.977]                   ...future.rng), started = ...future.startTime, 
  [03:00:26.977]                 version = "1.8")
  [03:00:26.977]         }, condition = base::local({
  [03:00:26.977]             c <- base::c
  [03:00:26.977]             inherits <- base::inherits
  [03:00:26.977]             invokeRestart <- base::invokeRestart
  [03:00:26.977]             length <- base::length
  [03:00:26.977]             list <- base::list
  [03:00:26.977]             seq.int <- base::seq.int
  [03:00:26.977]             signalCondition <- base::signalCondition
  [03:00:26.977]             sys.calls <- base::sys.calls
  [03:00:26.977]             Sys.time <- base::Sys.time
  [03:00:26.977]             `[[` <- base::`[[`
  [03:00:26.977]             `+` <- base::`+`
  [03:00:26.977]             `<<-` <- base::`<<-`
  [03:00:26.977]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:26.977]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:26.977]                   3L)]
  [03:00:26.977]             }
  [03:00:26.977]             function(cond) {
  [03:00:26.977]                 if (inherits(cond, "error")) {
  [03:00:26.977]                   sessionInformation <- function() {
  [03:00:26.977]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:26.977]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:26.977]                       search = base::search(), system = base::Sys.info())
  [03:00:26.977]                   }
  [03:00:26.977]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.977]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:26.977]                     cond$call), session = sessionInformation(), 
  [03:00:26.977]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:26.977]                   signalCondition(cond)
  [03:00:26.977]                 }
  [03:00:26.977]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:26.977]                 ))) {
  [03:00:26.977]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:26.977]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:26.977]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:26.977]                   if (!signal) {
  [03:00:26.977]                     muffleCondition <- function (cond) 
  [03:00:26.977]                     {
  [03:00:26.977]                       inherits <- base::inherits
  [03:00:26.977]                       invokeRestart <- base::invokeRestart
  [03:00:26.977]                       muffled <- FALSE
  [03:00:26.977]                       if (inherits(cond, "message")) {
  [03:00:26.977]                         invokeRestart("muffleMessage")
  [03:00:26.977]                         muffled <- TRUE
  [03:00:26.977]                       }
  [03:00:26.977]                       else if (inherits(cond, "warning")) {
  [03:00:26.977]                         invokeRestart("muffleWarning")
  [03:00:26.977]                         muffled <- TRUE
  [03:00:26.977]                       }
  [03:00:26.977]                       else if (inherits(cond, "condition")) {
  [03:00:26.977]                         computeRestarts <- base::computeRestarts
  [03:00:26.977]                         grepl <- base::grepl
  [03:00:26.977]                         is.null <- base::is.null
  [03:00:26.977]                         restarts <- computeRestarts(cond)
  [03:00:26.977]                         for (restart in restarts) {
  [03:00:26.977]                           name <- restart$name
  [03:00:26.977]                           if (is.null(name)) 
  [03:00:26.977]                             next
  [03:00:26.977]                           if (!grepl("^muffle", name)) 
  [03:00:26.977]                             next
  [03:00:26.977]                           invokeRestart(restart)
  [03:00:26.977]                           muffled <- TRUE
  [03:00:26.977]                           break
  [03:00:26.977]                         }
  [03:00:26.977]                       }
  [03:00:26.977]                       invisible(muffled)
  [03:00:26.977]                     }
  [03:00:26.977]                     muffleCondition(cond)
  [03:00:26.977]                   }
  [03:00:26.977]                 }
  [03:00:26.977]             }
  [03:00:26.977]         }))
  [03:00:26.977]     }, error = function(ex) {
  [03:00:26.977]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:26.977]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:26.977]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:26.977]     }, finally = {
  [03:00:26.977]         {
  [03:00:26.977]             NULL
  [03:00:26.977]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:26.977]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:26.977]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:26.977]                 label = NULL, ...) 
  [03:00:26.977]             {
  [03:00:26.977]                 if (substitute) 
  [03:00:26.977]                   expr <- substitute(expr)
  [03:00:26.977]                 local <- as.logical(local)
  [03:00:26.977]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:26.977]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:26.977]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:26.977]                   label = label, ...)
  [03:00:26.977]                 if (!future$lazy) 
  [03:00:26.977]                   future <- run(future)
  [03:00:26.977]                 invisible(future)
  [03:00:26.977]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:26.977]         }
  [03:00:26.977]         base::options(...future.oldOptions)
  [03:00:26.977]     })
  [03:00:26.977]     Sys.time
  [03:00:26.977]     if (base::is.na(NA)) {
  [03:00:26.977]     }
  [03:00:26.977]     else {
  [03:00:26.977]         base::sink(type = "output", split = FALSE)
  [03:00:26.977]         if (NA) {
  [03:00:26.977]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:26.977]         }
  [03:00:26.977]         else {
  [03:00:26.977]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:26.977]         }
  [03:00:26.977]         base::close(...future.stdout)
  [03:00:26.977]         ...future.stdout <- NULL
  [03:00:26.977]     }
  [03:00:26.977]     ...future.result$conditions <- ...future.conditions
  [03:00:26.977]     ...future.result
  [03:00:26.977] }
  [03:00:26.985] plan(): Setting new future strategy stack:
  [03:00:26.986] List of future strategies:
  [03:00:26.986] 1. sequential:
  [03:00:26.986]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.986]    - tweaked: FALSE
  [03:00:26.986]    - call: NULL
  [03:00:26.988] plan(): nbrOfWorkers() = 1
  [03:00:26.990] plan(): Setting new future strategy stack:
  [03:00:26.991] List of future strategies:
  [03:00:26.991] 1. sequential:
  [03:00:26.991]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:26.991]    - tweaked: FALSE
  [03:00:26.991]    - call: NULL
  [03:00:26.993] plan(): nbrOfWorkers() = 1
  [03:00:26.994] SequentialFuture started (and completed)
  [03:00:27.000] plan(): Setting new future strategy stack:
  [03:00:27.001] List of future strategies:
  [03:00:27.001] 1. sequential:
  [03:00:27.001]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.001]    - tweaked: FALSE
  [03:00:27.001]    - call: NULL
  [03:00:27.004] plan(): nbrOfWorkers() = 1
  [03:00:27.005] SequentialFuture started (and completed)
  [03:00:27.008] Packages needed by the future expression (n = 0): <none>
  [03:00:27.010] Packages needed by future strategies (n = 0): <none>
  [03:00:27.018] {
  [03:00:27.018]     {
  [03:00:27.018]         ...future.startTime <- base::Sys.time()
  [03:00:27.018]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:27.018]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:27.018]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:27.018]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:27.018]             future.resolve.recursive = NULL, width = 80L)
  [03:00:27.018]         {
  [03:00:27.018]             {
  [03:00:27.018]                 base::local({
  [03:00:27.018]                   has_future <- base::requireNamespace("future", 
  [03:00:27.018]                     quietly = TRUE)
  [03:00:27.018]                   version <- if (has_future) 
  [03:00:27.018]                     utils::packageVersion("future")
  [03:00:27.018]                   else NULL
  [03:00:27.018]                   if (!has_future || version < "1.8.0") {
  [03:00:27.018]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:27.018]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:27.018]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:27.018]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:27.018]                         "release", "version")], collapse = " "), 
  [03:00:27.018]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:27.018]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:27.018]                       info)
  [03:00:27.018]                     info <- base::paste(info, collapse = "; ")
  [03:00:27.018]                     if (!has_future) {
  [03:00:27.018]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:27.018]                         info)
  [03:00:27.018]                     }
  [03:00:27.018]                     else {
  [03:00:27.018]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:27.018]                         info, version)
  [03:00:27.018]                     }
  [03:00:27.018]                     base::stop(msg)
  [03:00:27.018]                   }
  [03:00:27.018]                 })
  [03:00:27.018]             }
  [03:00:27.018]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:27.018]         }
  [03:00:27.018]     }
  [03:00:27.018]     if (base::is.na(NA)) {
  [03:00:27.018]     }
  [03:00:27.018]     else {
  [03:00:27.018]         if (NA) {
  [03:00:27.018]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:27.018]                 open = "w")
  [03:00:27.018]         }
  [03:00:27.018]         else {
  [03:00:27.018]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:27.018]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:27.018]         }
  [03:00:27.018]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:27.018]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:27.018]             base::sink(type = "output", split = FALSE)
  [03:00:27.018]             base::close(...future.stdout)
  [03:00:27.018]         }, add = TRUE)
  [03:00:27.018]     }
  [03:00:27.018]     ...future.frame <- base::sys.nframe()
  [03:00:27.018]     ...future.conditions <- base::list()
  [03:00:27.018]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:27.018]     ...future.result <- base::tryCatch({
  [03:00:27.018]         base::withCallingHandlers({
  [03:00:27.018]             ...future.value <- base::withVisible(base::local({
  [03:00:27.018]                 x[[i - 2]] + x[[i - 1]]
  [03:00:27.018]             }))
  [03:00:27.018]             future::FutureResult(value = ...future.value$value, 
  [03:00:27.018]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.018]                   ...future.rng), started = ...future.startTime, 
  [03:00:27.018]                 version = "1.8")
  [03:00:27.018]         }, condition = base::local({
  [03:00:27.018]             c <- base::c
  [03:00:27.018]             inherits <- base::inherits
  [03:00:27.018]             invokeRestart <- base::invokeRestart
  [03:00:27.018]             length <- base::length
  [03:00:27.018]             list <- base::list
  [03:00:27.018]             seq.int <- base::seq.int
  [03:00:27.018]             signalCondition <- base::signalCondition
  [03:00:27.018]             sys.calls <- base::sys.calls
  [03:00:27.018]             Sys.time <- base::Sys.time
  [03:00:27.018]             `[[` <- base::`[[`
  [03:00:27.018]             `+` <- base::`+`
  [03:00:27.018]             `<<-` <- base::`<<-`
  [03:00:27.018]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:27.018]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:27.018]                   3L)]
  [03:00:27.018]             }
  [03:00:27.018]             function(cond) {
  [03:00:27.018]                 if (inherits(cond, "error")) {
  [03:00:27.018]                   sessionInformation <- function() {
  [03:00:27.018]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:27.018]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:27.018]                       search = base::search(), system = base::Sys.info())
  [03:00:27.018]                   }
  [03:00:27.018]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.018]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:27.018]                     cond$call), session = sessionInformation(), 
  [03:00:27.018]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:27.018]                   signalCondition(cond)
  [03:00:27.018]                 }
  [03:00:27.018]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:27.018]                 ))) {
  [03:00:27.018]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:27.018]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.018]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:27.018]                   if (!signal) {
  [03:00:27.018]                     muffleCondition <- function (cond) 
  [03:00:27.018]                     {
  [03:00:27.018]                       inherits <- base::inherits
  [03:00:27.018]                       invokeRestart <- base::invokeRestart
  [03:00:27.018]                       muffled <- FALSE
  [03:00:27.018]                       if (inherits(cond, "message")) {
  [03:00:27.018]                         invokeRestart("muffleMessage")
  [03:00:27.018]                         muffled <- TRUE
  [03:00:27.018]                       }
  [03:00:27.018]                       else if (inherits(cond, "warning")) {
  [03:00:27.018]                         invokeRestart("muffleWarning")
  [03:00:27.018]                         muffled <- TRUE
  [03:00:27.018]                       }
  [03:00:27.018]                       else if (inherits(cond, "condition")) {
  [03:00:27.018]                         computeRestarts <- base::computeRestarts
  [03:00:27.018]                         grepl <- base::grepl
  [03:00:27.018]                         is.null <- base::is.null
  [03:00:27.018]                         restarts <- computeRestarts(cond)
  [03:00:27.018]                         for (restart in restarts) {
  [03:00:27.018]                           name <- restart$name
  [03:00:27.018]                           if (is.null(name)) 
  [03:00:27.018]                             next
  [03:00:27.018]                           if (!grepl("^muffle", name)) 
  [03:00:27.018]                             next
  [03:00:27.018]                           invokeRestart(restart)
  [03:00:27.018]                           muffled <- TRUE
  [03:00:27.018]                           break
  [03:00:27.018]                         }
  [03:00:27.018]                       }
  [03:00:27.018]                       invisible(muffled)
  [03:00:27.018]                     }
  [03:00:27.018]                     muffleCondition(cond)
  [03:00:27.018]                   }
  [03:00:27.018]                 }
  [03:00:27.018]             }
  [03:00:27.018]         }))
  [03:00:27.018]     }, error = function(ex) {
  [03:00:27.018]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:27.018]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.018]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:27.018]     }, finally = {
  [03:00:27.018]         {
  [03:00:27.018]             NULL
  [03:00:27.018]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:27.018]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:27.018]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:27.018]                 label = NULL, ...) 
  [03:00:27.018]             {
  [03:00:27.018]                 if (substitute) 
  [03:00:27.018]                   expr <- substitute(expr)
  [03:00:27.018]                 local <- as.logical(local)
  [03:00:27.018]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:27.018]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:27.018]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:27.018]                   label = label, ...)
  [03:00:27.018]                 if (!future$lazy) 
  [03:00:27.018]                   future <- run(future)
  [03:00:27.018]                 invisible(future)
  [03:00:27.018]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:27.018]         }
  [03:00:27.018]         base::options(...future.oldOptions)
  [03:00:27.018]     })
  [03:00:27.018]     Sys.time
  [03:00:27.018]     if (base::is.na(NA)) {
  [03:00:27.018]     }
  [03:00:27.018]     else {
  [03:00:27.018]         base::sink(type = "output", split = FALSE)
  [03:00:27.018]         if (NA) {
  [03:00:27.018]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:27.018]         }
  [03:00:27.018]         else {
  [03:00:27.018]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:27.018]         }
  [03:00:27.018]         base::close(...future.stdout)
  [03:00:27.018]         ...future.stdout <- NULL
  [03:00:27.018]     }
  [03:00:27.018]     ...future.result$conditions <- ...future.conditions
  [03:00:27.018]     ...future.result
  [03:00:27.018] }
  [03:00:27.026] plan(): Setting new future strategy stack:
  [03:00:27.027] List of future strategies:
  [03:00:27.027] 1. sequential:
  [03:00:27.027]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.027]    - tweaked: FALSE
  [03:00:27.027]    - call: NULL
  [03:00:27.029] plan(): nbrOfWorkers() = 1
  [03:00:27.031] plan(): Setting new future strategy stack:
  [03:00:27.032] List of future strategies:
  [03:00:27.032] 1. sequential:
  [03:00:27.032]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.032]    - tweaked: FALSE
  [03:00:27.032]    - call: NULL
  [03:00:27.034] plan(): nbrOfWorkers() = 1
  [03:00:27.035] SequentialFuture started (and completed)
  [03:00:27.038] plan(): Setting new future strategy stack:
  [03:00:27.039] List of future strategies:
  [03:00:27.039] 1. sequential:
  [03:00:27.039]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.039]    - tweaked: FALSE
  [03:00:27.039]    - call: NULL
  [03:00:27.040] plan(): nbrOfWorkers() = 1
  [03:00:27.041] SequentialFuture started (and completed)
  [03:00:27.044] Packages needed by the future expression (n = 0): <none>
  [03:00:27.045] Packages needed by future strategies (n = 0): <none>
  [03:00:27.053] {
  [03:00:27.053]     {
  [03:00:27.053]         ...future.startTime <- base::Sys.time()
  [03:00:27.053]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:27.053]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:27.053]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:27.053]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:27.053]             future.resolve.recursive = NULL, width = 80L)
  [03:00:27.053]         {
  [03:00:27.053]             {
  [03:00:27.053]                 base::local({
  [03:00:27.053]                   has_future <- base::requireNamespace("future", 
  [03:00:27.053]                     quietly = TRUE)
  [03:00:27.053]                   version <- if (has_future) 
  [03:00:27.053]                     utils::packageVersion("future")
  [03:00:27.053]                   else NULL
  [03:00:27.053]                   if (!has_future || version < "1.8.0") {
  [03:00:27.053]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:27.053]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:27.053]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:27.053]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:27.053]                         "release", "version")], collapse = " "), 
  [03:00:27.053]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:27.053]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:27.053]                       info)
  [03:00:27.053]                     info <- base::paste(info, collapse = "; ")
  [03:00:27.053]                     if (!has_future) {
  [03:00:27.053]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:27.053]                         info)
  [03:00:27.053]                     }
  [03:00:27.053]                     else {
  [03:00:27.053]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:27.053]                         info, version)
  [03:00:27.053]                     }
  [03:00:27.053]                     base::stop(msg)
  [03:00:27.053]                   }
  [03:00:27.053]                 })
  [03:00:27.053]             }
  [03:00:27.053]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:27.053]         }
  [03:00:27.053]     }
  [03:00:27.053]     if (base::is.na(NA)) {
  [03:00:27.053]     }
  [03:00:27.053]     else {
  [03:00:27.053]         if (NA) {
  [03:00:27.053]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:27.053]                 open = "w")
  [03:00:27.053]         }
  [03:00:27.053]         else {
  [03:00:27.053]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:27.053]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:27.053]         }
  [03:00:27.053]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:27.053]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:27.053]             base::sink(type = "output", split = FALSE)
  [03:00:27.053]             base::close(...future.stdout)
  [03:00:27.053]         }, add = TRUE)
  [03:00:27.053]     }
  [03:00:27.053]     ...future.frame <- base::sys.nframe()
  [03:00:27.053]     ...future.conditions <- base::list()
  [03:00:27.053]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:27.053]     ...future.result <- base::tryCatch({
  [03:00:27.053]         base::withCallingHandlers({
  [03:00:27.053]             ...future.value <- base::withVisible(base::local({
  [03:00:27.053]                 x[[i - 2]] + x[[i - 1]]
  [03:00:27.053]             }))
  [03:00:27.053]             future::FutureResult(value = ...future.value$value, 
  [03:00:27.053]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.053]                   ...future.rng), started = ...future.startTime, 
  [03:00:27.053]                 version = "1.8")
  [03:00:27.053]         }, condition = base::local({
  [03:00:27.053]             c <- base::c
  [03:00:27.053]             inherits <- base::inherits
  [03:00:27.053]             invokeRestart <- base::invokeRestart
  [03:00:27.053]             length <- base::length
  [03:00:27.053]             list <- base::list
  [03:00:27.053]             seq.int <- base::seq.int
  [03:00:27.053]             signalCondition <- base::signalCondition
  [03:00:27.053]             sys.calls <- base::sys.calls
  [03:00:27.053]             Sys.time <- base::Sys.time
  [03:00:27.053]             `[[` <- base::`[[`
  [03:00:27.053]             `+` <- base::`+`
  [03:00:27.053]             `<<-` <- base::`<<-`
  [03:00:27.053]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:27.053]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:27.053]                   3L)]
  [03:00:27.053]             }
  [03:00:27.053]             function(cond) {
  [03:00:27.053]                 if (inherits(cond, "error")) {
  [03:00:27.053]                   sessionInformation <- function() {
  [03:00:27.053]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:27.053]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:27.053]                       search = base::search(), system = base::Sys.info())
  [03:00:27.053]                   }
  [03:00:27.053]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.053]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:27.053]                     cond$call), session = sessionInformation(), 
  [03:00:27.053]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:27.053]                   signalCondition(cond)
  [03:00:27.053]                 }
  [03:00:27.053]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:27.053]                 ))) {
  [03:00:27.053]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:27.053]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.053]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:27.053]                   if (!signal) {
  [03:00:27.053]                     muffleCondition <- function (cond) 
  [03:00:27.053]                     {
  [03:00:27.053]                       inherits <- base::inherits
  [03:00:27.053]                       invokeRestart <- base::invokeRestart
  [03:00:27.053]                       muffled <- FALSE
  [03:00:27.053]                       if (inherits(cond, "message")) {
  [03:00:27.053]                         invokeRestart("muffleMessage")
  [03:00:27.053]                         muffled <- TRUE
  [03:00:27.053]                       }
  [03:00:27.053]                       else if (inherits(cond, "warning")) {
  [03:00:27.053]                         invokeRestart("muffleWarning")
  [03:00:27.053]                         muffled <- TRUE
  [03:00:27.053]                       }
  [03:00:27.053]                       else if (inherits(cond, "condition")) {
  [03:00:27.053]                         computeRestarts <- base::computeRestarts
  [03:00:27.053]                         grepl <- base::grepl
  [03:00:27.053]                         is.null <- base::is.null
  [03:00:27.053]                         restarts <- computeRestarts(cond)
  [03:00:27.053]                         for (restart in restarts) {
  [03:00:27.053]                           name <- restart$name
  [03:00:27.053]                           if (is.null(name)) 
  [03:00:27.053]                             next
  [03:00:27.053]                           if (!grepl("^muffle", name)) 
  [03:00:27.053]                             next
  [03:00:27.053]                           invokeRestart(restart)
  [03:00:27.053]                           muffled <- TRUE
  [03:00:27.053]                           break
  [03:00:27.053]                         }
  [03:00:27.053]                       }
  [03:00:27.053]                       invisible(muffled)
  [03:00:27.053]                     }
  [03:00:27.053]                     muffleCondition(cond)
  [03:00:27.053]                   }
  [03:00:27.053]                 }
  [03:00:27.053]             }
  [03:00:27.053]         }))
  [03:00:27.053]     }, error = function(ex) {
  [03:00:27.053]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:27.053]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.053]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:27.053]     }, finally = {
  [03:00:27.053]         {
  [03:00:27.053]             NULL
  [03:00:27.053]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:27.053]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:27.053]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:27.053]                 label = NULL, ...) 
  [03:00:27.053]             {
  [03:00:27.053]                 if (substitute) 
  [03:00:27.053]                   expr <- substitute(expr)
  [03:00:27.053]                 local <- as.logical(local)
  [03:00:27.053]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:27.053]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:27.053]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:27.053]                   label = label, ...)
  [03:00:27.053]                 if (!future$lazy) 
  [03:00:27.053]                   future <- run(future)
  [03:00:27.053]                 invisible(future)
  [03:00:27.053]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:27.053]         }
  [03:00:27.053]         base::options(...future.oldOptions)
  [03:00:27.053]     })
  [03:00:27.053]     Sys.time
  [03:00:27.053]     if (base::is.na(NA)) {
  [03:00:27.053]     }
  [03:00:27.053]     else {
  [03:00:27.053]         base::sink(type = "output", split = FALSE)
  [03:00:27.053]         if (NA) {
  [03:00:27.053]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:27.053]         }
  [03:00:27.053]         else {
  [03:00:27.053]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:27.053]         }
  [03:00:27.053]         base::close(...future.stdout)
  [03:00:27.053]         ...future.stdout <- NULL
  [03:00:27.053]     }
  [03:00:27.053]     ...future.result$conditions <- ...future.conditions
  [03:00:27.053]     ...future.result
  [03:00:27.053] }
  [03:00:27.061] plan(): Setting new future strategy stack:
  [03:00:27.062] List of future strategies:
  [03:00:27.062] 1. sequential:
  [03:00:27.062]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.062]    - tweaked: FALSE
  [03:00:27.062]    - call: NULL
  [03:00:27.063] plan(): nbrOfWorkers() = 1
  [03:00:27.065] plan(): Setting new future strategy stack:
  [03:00:27.066] List of future strategies:
  [03:00:27.066] 1. sequential:
  [03:00:27.066]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.066]    - tweaked: FALSE
  [03:00:27.066]    - call: NULL
  [03:00:27.068] plan(): nbrOfWorkers() = 1
  [03:00:27.069] SequentialFuture started (and completed)
  [03:00:27.070] plan(): Setting new future strategy stack:
  [03:00:27.071] List of future strategies:
  [03:00:27.071] 1. sequential:
  [03:00:27.071]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.071]    - tweaked: FALSE
  [03:00:27.071]    - call: NULL
  [03:00:27.072] plan(): nbrOfWorkers() = 1
  [03:00:27.073] SequentialFuture started (and completed)
  [03:00:27.076] Packages needed by the future expression (n = 0): <none>
  [03:00:27.077] Packages needed by future strategies (n = 0): <none>
  [03:00:27.084] {
  [03:00:27.084]     {
  [03:00:27.084]         ...future.startTime <- base::Sys.time()
  [03:00:27.084]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:27.084]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:27.084]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:27.084]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:27.084]             future.resolve.recursive = NULL, width = 80L)
  [03:00:27.084]         {
  [03:00:27.084]             {
  [03:00:27.084]                 base::local({
  [03:00:27.084]                   has_future <- base::requireNamespace("future", 
  [03:00:27.084]                     quietly = TRUE)
  [03:00:27.084]                   version <- if (has_future) 
  [03:00:27.084]                     utils::packageVersion("future")
  [03:00:27.084]                   else NULL
  [03:00:27.084]                   if (!has_future || version < "1.8.0") {
  [03:00:27.084]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:00:27.084]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:00:27.084]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:27.084]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:27.084]                         "release", "version")], collapse = " "), 
  [03:00:27.084]                       hostname = base::Sys.info()[["nodename"]])
  [03:00:27.084]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:27.084]                       info)
  [03:00:27.084]                     info <- base::paste(info, collapse = "; ")
  [03:00:27.084]                     if (!has_future) {
  [03:00:27.084]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:27.084]                         info)
  [03:00:27.084]                     }
  [03:00:27.084]                     else {
  [03:00:27.084]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:27.084]                         info, version)
  [03:00:27.084]                     }
  [03:00:27.084]                     base::stop(msg)
  [03:00:27.084]                   }
  [03:00:27.084]                 })
  [03:00:27.084]             }
  [03:00:27.084]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:27.084]         }
  [03:00:27.084]     }
  [03:00:27.084]     if (base::is.na(NA)) {
  [03:00:27.084]     }
  [03:00:27.084]     else {
  [03:00:27.084]         if (NA) {
  [03:00:27.084]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:27.084]                 open = "w")
  [03:00:27.084]         }
  [03:00:27.084]         else {
  [03:00:27.084]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:27.084]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:27.084]         }
  [03:00:27.084]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:27.084]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:27.084]             base::sink(type = "output", split = FALSE)
  [03:00:27.084]             base::close(...future.stdout)
  [03:00:27.084]         }, add = TRUE)
  [03:00:27.084]     }
  [03:00:27.084]     ...future.frame <- base::sys.nframe()
  [03:00:27.084]     ...future.conditions <- base::list()
  [03:00:27.084]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:27.084]     ...future.result <- base::tryCatch({
  [03:00:27.084]         base::withCallingHandlers({
  [03:00:27.084]             ...future.value <- base::withVisible(base::local({
  [03:00:27.084]                 x[[i - 2]] + x[[i - 1]]
  [03:00:27.084]             }))
  [03:00:27.084]             future::FutureResult(value = ...future.value$value, 
  [03:00:27.084]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.084]                   ...future.rng), started = ...future.startTime, 
  [03:00:27.084]                 version = "1.8")
  [03:00:27.084]         }, condition = base::local({
  [03:00:27.084]             c <- base::c
  [03:00:27.084]             inherits <- base::inherits
  [03:00:27.084]             invokeRestart <- base::invokeRestart
  [03:00:27.084]             length <- base::length
  [03:00:27.084]             list <- base::list
  [03:00:27.084]             seq.int <- base::seq.int
  [03:00:27.084]             signalCondition <- base::signalCondition
  [03:00:27.084]             sys.calls <- base::sys.calls
  [03:00:27.084]             Sys.time <- base::Sys.time
  [03:00:27.084]             `[[` <- base::`[[`
  [03:00:27.084]             `+` <- base::`+`
  [03:00:27.084]             `<<-` <- base::`<<-`
  [03:00:27.084]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:27.084]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:27.084]                   3L)]
  [03:00:27.084]             }
  [03:00:27.084]             function(cond) {
  [03:00:27.084]                 if (inherits(cond, "error")) {
  [03:00:27.084]                   sessionInformation <- function() {
  [03:00:27.084]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:27.084]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:27.084]                       search = base::search(), system = base::Sys.info())
  [03:00:27.084]                   }
  [03:00:27.084]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.084]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:27.084]                     cond$call), session = sessionInformation(), 
  [03:00:27.084]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:27.084]                   signalCondition(cond)
  [03:00:27.084]                 }
  [03:00:27.084]                 else if (inherits(cond, c("error", "immediateCondition"
  [03:00:27.084]                 ))) {
  [03:00:27.084]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:27.084]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.084]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:27.084]                   if (!signal) {
  [03:00:27.084]                     muffleCondition <- function (cond) 
  [03:00:27.084]                     {
  [03:00:27.084]                       inherits <- base::inherits
  [03:00:27.084]                       invokeRestart <- base::invokeRestart
  [03:00:27.084]                       muffled <- FALSE
  [03:00:27.084]                       if (inherits(cond, "message")) {
  [03:00:27.084]                         invokeRestart("muffleMessage")
  [03:00:27.084]                         muffled <- TRUE
  [03:00:27.084]                       }
  [03:00:27.084]                       else if (inherits(cond, "warning")) {
  [03:00:27.084]                         invokeRestart("muffleWarning")
  [03:00:27.084]                         muffled <- TRUE
  [03:00:27.084]                       }
  [03:00:27.084]                       else if (inherits(cond, "condition")) {
  [03:00:27.084]                         computeRestarts <- base::computeRestarts
  [03:00:27.084]                         grepl <- base::grepl
  [03:00:27.084]                         is.null <- base::is.null
  [03:00:27.084]                         restarts <- computeRestarts(cond)
  [03:00:27.084]                         for (restart in restarts) {
  [03:00:27.084]                           name <- restart$name
  [03:00:27.084]                           if (is.null(name)) 
  [03:00:27.084]                             next
  [03:00:27.084]                           if (!grepl("^muffle", name)) 
  [03:00:27.084]                             next
  [03:00:27.084]                           invokeRestart(restart)
  [03:00:27.084]                           muffled <- TRUE
  [03:00:27.084]                           break
  [03:00:27.084]                         }
  [03:00:27.084]                       }
  [03:00:27.084]                       invisible(muffled)
  [03:00:27.084]                     }
  [03:00:27.084]                     muffleCondition(cond)
  [03:00:27.084]                   }
  [03:00:27.084]                 }
  [03:00:27.084]             }
  [03:00:27.084]         }))
  [03:00:27.084]     }, error = function(ex) {
  [03:00:27.084]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:27.084]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.084]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:27.084]     }, finally = {
  [03:00:27.084]         {
  [03:00:27.084]             NULL
  [03:00:27.084]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:27.084]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:27.084]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:27.084]                 label = NULL, ...) 
  [03:00:27.084]             {
  [03:00:27.084]                 if (substitute) 
  [03:00:27.084]                   expr <- substitute(expr)
  [03:00:27.084]                 local <- as.logical(local)
  [03:00:27.084]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:27.084]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:27.084]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:27.084]                   label = label, ...)
  [03:00:27.084]                 if (!future$lazy) 
  [03:00:27.084]                   future <- run(future)
  [03:00:27.084]                 invisible(future)
  [03:00:27.084]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:27.084]         }
  [03:00:27.084]         base::options(...future.oldOptions)
  [03:00:27.084]     })
  [03:00:27.084]     Sys.time
  [03:00:27.084]     if (base::is.na(NA)) {
  [03:00:27.084]     }
  [03:00:27.084]     else {
  [03:00:27.084]         base::sink(type = "output", split = FALSE)
  [03:00:27.084]         if (NA) {
  [03:00:27.084]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:27.084]         }
  [03:00:27.084]         else {
  [03:00:27.084]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:27.084]         }
  [03:00:27.084]         base::close(...future.stdout)
  [03:00:27.084]         ...future.stdout <- NULL
  [03:00:27.084]     }
  [03:00:27.084]     ...future.result$conditions <- ...future.conditions
  [03:00:27.084]     ...future.result
  [03:00:27.084] }
  [03:00:27.092] plan(): Setting new future strategy stack:
  [03:00:27.093] List of future strategies:
  [03:00:27.093] 1. sequential:
  [03:00:27.093]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.093]    - tweaked: FALSE
  [03:00:27.093]    - call: NULL
  [03:00:27.095] plan(): nbrOfWorkers() = 1
  [03:00:27.097] plan(): Setting new future strategy stack:
  [03:00:27.097] List of future strategies:
  [03:00:27.097] 1. sequential:
  [03:00:27.097]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.097]    - tweaked: FALSE
  [03:00:27.097]    - call: NULL
  [03:00:27.099] plan(): nbrOfWorkers() = 1
  [03:00:27.100] SequentialFuture started (and completed)
  [03:00:27.101] plan(): Setting new future strategy stack:
  [03:00:27.102] List of future strategies:
  [03:00:27.102] 1. sequential:
  [03:00:27.102]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.102]    - tweaked: FALSE
  [03:00:27.102]    - call: plan(sequential)
  [03:00:27.103] plan(): nbrOfWorkers() = 1
  [03:00:27.104] SequentialFuture started (and completed)
  [1] 7778742049
  
  > ## Reset plan
  > plan(oplan)
  [03:00:27.105] plan(): Setting new future strategy stack:
  [03:00:27.106] List of future strategies:
  [03:00:27.106] 1. sequential:
  [03:00:27.106]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.106]    - tweaked: FALSE
  [03:00:27.106]    - call: future::plan("sequential")
  [03:00:27.107] plan(): nbrOfWorkers() = 1
  > message("*** Fibonacci demo of the 'future' package ... DONE")
  *** Fibonacci demo of the 'future' package ... DONE
  > 
  > 
  > message("*** Mandelbrot demo of the 'future' package ...")
  *** Mandelbrot demo of the 'future' package ...
  > if (getRversion() >= "3.2.0" && !isWin32) {
  +   options(future.demo.mandelbrot.nrow = 2L)
  +   options(future.demo.mandelbrot.resolution = 50L)
  +   options(future.demo.mandelbrot.delay = FALSE)
  +   
  +   for (cores in 1:availCores) {
  +     message(sprintf("Testing with %d cores ...", cores))
  +     options(mc.cores = cores)
  +   
  +     for (strategy in supportedStrategies(cores)) {
  +       message(sprintf("- plan('%s') ...", strategy))
  +       plan(strategy)
  +       demo("mandelbrot", package = "future", ask = FALSE)
  +       message(sprintf("- plan('%s') ... DONE", strategy))
  +     }
  +   
  +     message(sprintf("Testing with %d cores ... DONE", cores))
  +   } ## for (cores ...)
  + } else {
  +   message(" - This demo requires R (>= 3.2.0). Skipping test. (Skipping also on Win32 i386 for speed)")
  + }
  Testing with 1 cores ...
  - plan('sequential') ...
  [03:00:27.138] plan(): Setting new future strategy stack:
  [03:00:27.138] List of future strategies:
  [03:00:27.138] 1. sequential:
  [03:00:27.138]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.138]    - tweaked: FALSE
  [03:00:27.138]    - call: plan(strategy)
  [03:00:27.140] plan(): nbrOfWorkers() = 1
  
  
  	demo(mandelbrot)
  	---- ~~~~~~~~~~
  
  > library("future")
  
  > library("graphics")
  
  > plot_what_is_done <- function(counts) {
  +   for (kk in seq_along(counts)) {
  +     f <- counts[[kk]]
  + 
  +     ## Already plotted?
  +     if (!inherits(f, "Future")) next
  + 
  +     ## Not resolved?
  +     if (!resolved(f)) next
  + 
  +     message(sprintf("Plotting tile #%d of %d ...", kk, n))
  +     counts[[kk]] <- value(f)
  +     screen(kk)
  +     plot(counts[[kk]])
  +   }
  + 
  +   counts
  + }
  
  > ## Options
  > region <- getOption("future.demo.mandelbrot.region", 1L)
  
  > if (!is.list(region)) {
  +   if (region == 1L) {
  +     region <- list(xmid = -0.75, ymid = 0.0, side = 3.0)
  +   } else if (region == 2L) {
  +     region <- list(xmid = 0.283, ymid = -0.0095, side = 0.00026)
  +   } else if (region == 3L) {
  +     region <- list(xmid = 0.282989, ymid = -0.01, side = 3e-8)
  +   }
  + }
  
  > nrow <- getOption("future.demo.mandelbrot.nrow", 3L)
  
  > resolution <- getOption("future.demo.mandelbrot.resolution", 400L)
  
  > delay <- getOption("future.demo.mandelbrot.delay", interactive())
  
  > if (isTRUE(delay)) {
  +   delay <- function(counts) Sys.sleep(rexp(1, rate = 2))
  + } else if (!is.function(delay)) {
  +   delay <- function(counts) {}
  + }
  
  > ## Generate Mandelbrot tiles to be computed
  > Cs <- mandelbrot_tiles(xmid = region$xmid, ymid = region$ymid,
  +                        side = region$side, nrow = nrow,
  +                        resolution = resolution)
  
  > if (interactive()) {
  +   dev.new()
  +   plot.new()
  +   split.screen(dim(Cs))
  +   for (ii in seq_along(Cs)) {
  +     screen(ii)
  +     par(mar = c(0, 0, 0, 0))
  +     text(x = 1 / 2, y = 1 / 2, sprintf("Future #%d\nunresolved", ii), cex = 2)
  +   }
  + } else {
  +   split.screen(dim(Cs))
  + }
  [1] 1 2 3 4
  
  > ## Create all Mandelbrot tiles via lazy futures
  > n <- length(Cs)
  
  > message(sprintf("Creating %d Mandelbrot tiles:", n), appendLF = FALSE)
  Creating 4 Mandelbrot tiles:
  > counts <- lapply(seq_along(Cs), FUN=function(ii) {
  +   message(" ", ii, appendLF = FALSE)
  +   C <- Cs[[ii]]
  +   future({
  +     message(sprintf("Calculating tile #%d of %d ...", ii, n), appendLF = FALSE)
  +     fit <- mandelbrot(C)
  + 
  +     ## Emulate slowness
  +     delay(fit)
  + 
  +     message(" done")
  +     fit
  +   }, lazy = TRUE)
  + })
   1[03:00:27.238] getGlobalsAndPackages() ...
  [03:00:27.238] Searching for globals...
  [03:00:27.248] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [03:00:27.249] Searching for globals ... DONE
  [03:00:27.250] Resolving globals: FALSE
  [03:00:27.251] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [03:00:27.252] - globals: [4] 'ii', 'n', 'C', 'delay'
  [03:00:27.253] - packages: [1] 'future'
  [03:00:27.253] getGlobalsAndPackages() ... DONE
   2[03:00:27.269] getGlobalsAndPackages() ...
  [03:00:27.270] Searching for globals...
  [03:00:27.278] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [03:00:27.278] Searching for globals ... DONE
  [03:00:27.279] Resolving globals: FALSE
  [03:00:27.286] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [03:00:27.287] - globals: [4] 'ii', 'n', 'C', 'delay'
  [03:00:27.288] - packages: [1] 'future'
  [03:00:27.288] getGlobalsAndPackages() ... DONE
   3[03:00:27.289] getGlobalsAndPackages() ...
  [03:00:27.290] Searching for globals...
  [03:00:27.298] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [03:00:27.299] Searching for globals ... DONE
  [03:00:27.300] Resolving globals: FALSE
  [03:00:27.302] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [03:00:27.302] - globals: [4] 'ii', 'n', 'C', 'delay'
  [03:00:27.303] - packages: [1] 'future'
  [03:00:27.303] getGlobalsAndPackages() ... DONE
   4[03:00:27.305] getGlobalsAndPackages() ...
  [03:00:27.305] Searching for globals...
  [03:00:27.313] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [03:00:27.314] Searching for globals ... DONE
  [03:00:27.314] Resolving globals: FALSE
  [03:00:27.316] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [03:00:27.317] - globals: [4] 'ii', 'n', 'C', 'delay'
  [03:00:27.317] - packages: [1] 'future'
  [03:00:27.318] getGlobalsAndPackages() ... DONE
  
  > message(".")
  .
  
  > ## Calculate and plot tiles
  > repeat {
  +   counts <- plot_what_is_done(counts)
  +   if (!any(sapply(counts, FUN = inherits, "Future"))) break
  + }
  [03:00:27.353] Packages needed by the future expression (n = 1): 'future'
  [03:00:27.354] Packages needed by future strategies (n = 0): <none>
  [03:00:27.366] {
  [03:00:27.366]     {
  [03:00:27.366]         ...future.startTime <- base::Sys.time()
  [03:00:27.366]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:27.366]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:27.366]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:27.366]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:27.366]             future.resolve.recursive = NULL, width = 80L)
  [03:00:27.366]         {
  [03:00:27.366]             {
  [03:00:27.366]                 {
  [03:00:27.366]                   base::local({
  [03:00:27.366]                     has_future <- base::requireNamespace("future", 
  [03:00:27.366]                       quietly = TRUE)
  [03:00:27.366]                     version <- if (has_future) 
  [03:00:27.366]                       utils::packageVersion("future")
  [03:00:27.366]                     else NULL
  [03:00:27.366]                     if (!has_future || version < "1.8.0") {
  [03:00:27.366]                       info <- base::c(r_version = base::gsub("R version ", 
  [03:00:27.366]                         "", base::R.version$version.string), 
  [03:00:27.366]                         platform = base::sprintf("%s (%s-bit)", 
  [03:00:27.366]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:27.366]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:27.366]                           "release", "version")], collapse = " "), 
  [03:00:27.366]                         hostname = base::Sys.info()[["nodename"]])
  [03:00:27.366]                       info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:27.366]                         info)
  [03:00:27.366]                       info <- base::paste(info, collapse = "; ")
  [03:00:27.366]                       if (!has_future) {
  [03:00:27.366]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:27.366]                           info)
  [03:00:27.366]                       }
  [03:00:27.366]                       else {
  [03:00:27.366]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:27.366]                           info, version)
  [03:00:27.366]                       }
  [03:00:27.366]                       base::stop(msg)
  [03:00:27.366]                     }
  [03:00:27.366]                   })
  [03:00:27.366]                 }
  [03:00:27.366]                 base::local({
  [03:00:27.366]                   for (pkg in "future") {
  [03:00:27.366]                     base::loadNamespace(pkg)
  [03:00:27.366]                     base::library(pkg, character.only = TRUE)
  [03:00:27.366]                   }
  [03:00:27.366]                 })
  [03:00:27.366]             }
  [03:00:27.366]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:27.366]         }
  [03:00:27.366]     }
  [03:00:27.366]     if (base::is.na(TRUE)) {
  [03:00:27.366]     }
  [03:00:27.366]     else {
  [03:00:27.366]         if (TRUE) {
  [03:00:27.366]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:27.366]                 open = "w")
  [03:00:27.366]         }
  [03:00:27.366]         else {
  [03:00:27.366]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:27.366]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:27.366]         }
  [03:00:27.366]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:27.366]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:27.366]             base::sink(type = "output", split = FALSE)
  [03:00:27.366]             base::close(...future.stdout)
  [03:00:27.366]         }, add = TRUE)
  [03:00:27.366]     }
  [03:00:27.366]     ...future.frame <- base::sys.nframe()
  [03:00:27.366]     ...future.conditions <- base::list()
  [03:00:27.366]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:27.366]     ...future.result <- base::tryCatch({
  [03:00:27.366]         base::withCallingHandlers({
  [03:00:27.366]             ...future.value <- base::withVisible(base::local({
  [03:00:27.366]                 message(sprintf("Calculating tile #%d of %d ...", 
  [03:00:27.366]                   ii, n), appendLF = FALSE)
  [03:00:27.366]                 fit <- mandelbrot(C)
  [03:00:27.366]                 delay(fit)
  [03:00:27.366]                 message(" done")
  [03:00:27.366]                 fit
  [03:00:27.366]             }))
  [03:00:27.366]             future::FutureResult(value = ...future.value$value, 
  [03:00:27.366]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.366]                   ...future.rng), started = ...future.startTime, 
  [03:00:27.366]                 version = "1.8")
  [03:00:27.366]         }, condition = base::local({
  [03:00:27.366]             c <- base::c
  [03:00:27.366]             inherits <- base::inherits
  [03:00:27.366]             invokeRestart <- base::invokeRestart
  [03:00:27.366]             length <- base::length
  [03:00:27.366]             list <- base::list
  [03:00:27.366]             seq.int <- base::seq.int
  [03:00:27.366]             signalCondition <- base::signalCondition
  [03:00:27.366]             sys.calls <- base::sys.calls
  [03:00:27.366]             Sys.time <- base::Sys.time
  [03:00:27.366]             `[[` <- base::`[[`
  [03:00:27.366]             `+` <- base::`+`
  [03:00:27.366]             `<<-` <- base::`<<-`
  [03:00:27.366]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:27.366]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:27.366]                   3L)]
  [03:00:27.366]             }
  [03:00:27.366]             function(cond) {
  [03:00:27.366]                 if (inherits(cond, "error")) {
  [03:00:27.366]                   sessionInformation <- function() {
  [03:00:27.366]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:27.366]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:27.366]                       search = base::search(), system = base::Sys.info())
  [03:00:27.366]                   }
  [03:00:27.366]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.366]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:27.366]                     cond$call), session = sessionInformation(), 
  [03:00:27.366]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:27.366]                   signalCondition(cond)
  [03:00:27.366]                 }
  [03:00:27.366]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:00:27.366]                 ))) {
  [03:00:27.366]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:27.366]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.366]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:27.366]                   if (!signal) {
  [03:00:27.366]                     muffleCondition <- function (cond) 
  [03:00:27.366]                     {
  [03:00:27.366]                       inherits <- base::inherits
  [03:00:27.366]                       invokeRestart <- base::invokeRestart
  [03:00:27.366]                       muffled <- FALSE
  [03:00:27.366]                       if (inherits(cond, "message")) {
  [03:00:27.366]                         invokeRestart("muffleMessage")
  [03:00:27.366]                         muffled <- TRUE
  [03:00:27.366]                       }
  [03:00:27.366]                       else if (inherits(cond, "warning")) {
  [03:00:27.366]                         invokeRestart("muffleWarning")
  [03:00:27.366]                         muffled <- TRUE
  [03:00:27.366]                       }
  [03:00:27.366]                       else if (inherits(cond, "condition")) {
  [03:00:27.366]                         computeRestarts <- base::computeRestarts
  [03:00:27.366]                         grepl <- base::grepl
  [03:00:27.366]                         is.null <- base::is.null
  [03:00:27.366]                         restarts <- computeRestarts(cond)
  [03:00:27.366]                         for (restart in restarts) {
  [03:00:27.366]                           name <- restart$name
  [03:00:27.366]                           if (is.null(name)) 
  [03:00:27.366]                             next
  [03:00:27.366]                           if (!grepl("^muffle", name)) 
  [03:00:27.366]                             next
  [03:00:27.366]                           invokeRestart(restart)
  [03:00:27.366]                           muffled <- TRUE
  [03:00:27.366]                           break
  [03:00:27.366]                         }
  [03:00:27.366]                       }
  [03:00:27.366]                       invisible(muffled)
  [03:00:27.366]                     }
  [03:00:27.366]                     muffleCondition(cond)
  [03:00:27.366]                   }
  [03:00:27.366]                 }
  [03:00:27.366]             }
  [03:00:27.366]         }))
  [03:00:27.366]     }, error = function(ex) {
  [03:00:27.366]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:27.366]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.366]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:27.366]     }, finally = {
  [03:00:27.366]         {
  [03:00:27.366]             NULL
  [03:00:27.366]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:27.366]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:27.366]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:27.366]                 label = NULL, ...) 
  [03:00:27.366]             {
  [03:00:27.366]                 if (substitute) 
  [03:00:27.366]                   expr <- substitute(expr)
  [03:00:27.366]                 local <- as.logical(local)
  [03:00:27.366]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:27.366]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:27.366]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:27.366]                   label = label, ...)
  [03:00:27.366]                 if (!future$lazy) 
  [03:00:27.366]                   future <- run(future)
  [03:00:27.366]                 invisible(future)
  [03:00:27.366]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:27.366]         }
  [03:00:27.366]         base::options(...future.oldOptions)
  [03:00:27.366]     })
  [03:00:27.366]     Sys.time
  [03:00:27.366]     if (base::is.na(TRUE)) {
  [03:00:27.366]     }
  [03:00:27.366]     else {
  [03:00:27.366]         base::sink(type = "output", split = FALSE)
  [03:00:27.366]         if (TRUE) {
  [03:00:27.366]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:27.366]         }
  [03:00:27.366]         else {
  [03:00:27.366]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:27.366]         }
  [03:00:27.366]         base::close(...future.stdout)
  [03:00:27.366]         ...future.stdout <- NULL
  [03:00:27.366]     }
  [03:00:27.366]     ...future.result$conditions <- ...future.conditions
  [03:00:27.366]     ...future.result
  [03:00:27.366] }
  [03:00:27.374] plan(): Setting new future strategy stack:
  [03:00:27.374] List of future strategies:
  [03:00:27.374] 1. sequential:
  [03:00:27.374]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.374]    - tweaked: FALSE
  [03:00:27.374]    - call: NULL
  [03:00:27.376] plan(): nbrOfWorkers() = 1
  [03:00:27.381] plan(): Setting new future strategy stack:
  [03:00:27.381] List of future strategies:
  [03:00:27.381] 1. sequential:
  [03:00:27.381]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.381]    - tweaked: FALSE
  [03:00:27.381]    - call: plan(strategy)
  [03:00:27.383] plan(): nbrOfWorkers() = 1
  [03:00:27.384] SequentialFuture started (and completed)
  [03:00:27.384] signalConditions() ...
  [03:00:27.385]  - include = 'immediateCondition'
  [03:00:27.385]  - exclude = 
  [03:00:27.386]  - resignal = FALSE
  [03:00:27.386]  - Number of conditions: 2
  [03:00:27.387] signalConditions() ... done
  Plotting tile #1 of 4 ...
  [03:00:27.388] signalConditions() ...
  [03:00:27.388]  - include = 'immediateCondition'
  [03:00:27.389]  - exclude = 
  [03:00:27.389]  - resignal = FALSE
  [03:00:27.389]  - Number of conditions: 2
  [03:00:27.390] signalConditions() ... done
  [03:00:27.390] Future state: 'finished'
  [03:00:27.391] signalConditions() ...
  [03:00:27.391]  - include = 'condition'
  [03:00:27.392]  - exclude = 'immediateCondition'
  [03:00:27.392]  - resignal = TRUE
  [03:00:27.392]  - Number of conditions: 2
  [03:00:27.393]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #1 of 4 ...[03:00:27.393]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [03:00:27.394] signalConditions() ... done
  [03:00:27.401] Packages needed by the future expression (n = 1): 'future'
  [03:00:27.402] Packages needed by future strategies (n = 0): <none>
  [03:00:27.409] {
  [03:00:27.409]     {
  [03:00:27.409]         ...future.startTime <- base::Sys.time()
  [03:00:27.409]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:27.409]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:27.409]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:27.409]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:27.409]             future.resolve.recursive = NULL, width = 80L)
  [03:00:27.409]         {
  [03:00:27.409]             {
  [03:00:27.409]                 {
  [03:00:27.409]                   base::local({
  [03:00:27.409]                     has_future <- base::requireNamespace("future", 
  [03:00:27.409]                       quietly = TRUE)
  [03:00:27.409]                     version <- if (has_future) 
  [03:00:27.409]                       utils::packageVersion("future")
  [03:00:27.409]                     else NULL
  [03:00:27.409]                     if (!has_future || version < "1.8.0") {
  [03:00:27.409]                       info <- base::c(r_version = base::gsub("R version ", 
  [03:00:27.409]                         "", base::R.version$version.string), 
  [03:00:27.409]                         platform = base::sprintf("%s (%s-bit)", 
  [03:00:27.409]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:27.409]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:27.409]                           "release", "version")], collapse = " "), 
  [03:00:27.409]                         hostname = base::Sys.info()[["nodename"]])
  [03:00:27.409]                       info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:27.409]                         info)
  [03:00:27.409]                       info <- base::paste(info, collapse = "; ")
  [03:00:27.409]                       if (!has_future) {
  [03:00:27.409]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:27.409]                           info)
  [03:00:27.409]                       }
  [03:00:27.409]                       else {
  [03:00:27.409]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:27.409]                           info, version)
  [03:00:27.409]                       }
  [03:00:27.409]                       base::stop(msg)
  [03:00:27.409]                     }
  [03:00:27.409]                   })
  [03:00:27.409]                 }
  [03:00:27.409]                 base::local({
  [03:00:27.409]                   for (pkg in "future") {
  [03:00:27.409]                     base::loadNamespace(pkg)
  [03:00:27.409]                     base::library(pkg, character.only = TRUE)
  [03:00:27.409]                   }
  [03:00:27.409]                 })
  [03:00:27.409]             }
  [03:00:27.409]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:27.409]         }
  [03:00:27.409]     }
  [03:00:27.409]     if (base::is.na(TRUE)) {
  [03:00:27.409]     }
  [03:00:27.409]     else {
  [03:00:27.409]         if (TRUE) {
  [03:00:27.409]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:27.409]                 open = "w")
  [03:00:27.409]         }
  [03:00:27.409]         else {
  [03:00:27.409]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:27.409]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:27.409]         }
  [03:00:27.409]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:27.409]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:27.409]             base::sink(type = "output", split = FALSE)
  [03:00:27.409]             base::close(...future.stdout)
  [03:00:27.409]         }, add = TRUE)
  [03:00:27.409]     }
  [03:00:27.409]     ...future.frame <- base::sys.nframe()
  [03:00:27.409]     ...future.conditions <- base::list()
  [03:00:27.409]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:27.409]     ...future.result <- base::tryCatch({
  [03:00:27.409]         base::withCallingHandlers({
  [03:00:27.409]             ...future.value <- base::withVisible(base::local({
  [03:00:27.409]                 message(sprintf("Calculating tile #%d of %d ...", 
  [03:00:27.409]                   ii, n), appendLF = FALSE)
  [03:00:27.409]                 fit <- mandelbrot(C)
  [03:00:27.409]                 delay(fit)
  [03:00:27.409]                 message(" done")
  [03:00:27.409]                 fit
  [03:00:27.409]             }))
  [03:00:27.409]             future::FutureResult(value = ...future.value$value, 
  [03:00:27.409]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.409]                   ...future.rng), started = ...future.startTime, 
  [03:00:27.409]                 version = "1.8")
  [03:00:27.409]         }, condition = base::local({
  [03:00:27.409]             c <- base::c
  [03:00:27.409]             inherits <- base::inherits
  [03:00:27.409]             invokeRestart <- base::invokeRestart
  [03:00:27.409]             length <- base::length
  [03:00:27.409]             list <- base::list
  [03:00:27.409]             seq.int <- base::seq.int
  [03:00:27.409]             signalCondition <- base::signalCondition
  [03:00:27.409]             sys.calls <- base::sys.calls
  [03:00:27.409]             Sys.time <- base::Sys.time
  [03:00:27.409]             `[[` <- base::`[[`
  [03:00:27.409]             `+` <- base::`+`
  [03:00:27.409]             `<<-` <- base::`<<-`
  [03:00:27.409]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:27.409]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:27.409]                   3L)]
  [03:00:27.409]             }
  [03:00:27.409]             function(cond) {
  [03:00:27.409]                 if (inherits(cond, "error")) {
  [03:00:27.409]                   sessionInformation <- function() {
  [03:00:27.409]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:27.409]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:27.409]                       search = base::search(), system = base::Sys.info())
  [03:00:27.409]                   }
  [03:00:27.409]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.409]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:27.409]                     cond$call), session = sessionInformation(), 
  [03:00:27.409]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:27.409]                   signalCondition(cond)
  [03:00:27.409]                 }
  [03:00:27.409]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:00:27.409]                 ))) {
  [03:00:27.409]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:27.409]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.409]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:27.409]                   if (!signal) {
  [03:00:27.409]                     muffleCondition <- function (cond) 
  [03:00:27.409]                     {
  [03:00:27.409]                       inherits <- base::inherits
  [03:00:27.409]                       invokeRestart <- base::invokeRestart
  [03:00:27.409]                       muffled <- FALSE
  [03:00:27.409]                       if (inherits(cond, "message")) {
  [03:00:27.409]                         invokeRestart("muffleMessage")
  [03:00:27.409]                         muffled <- TRUE
  [03:00:27.409]                       }
  [03:00:27.409]                       else if (inherits(cond, "warning")) {
  [03:00:27.409]                         invokeRestart("muffleWarning")
  [03:00:27.409]                         muffled <- TRUE
  [03:00:27.409]                       }
  [03:00:27.409]                       else if (inherits(cond, "condition")) {
  [03:00:27.409]                         computeRestarts <- base::computeRestarts
  [03:00:27.409]                         grepl <- base::grepl
  [03:00:27.409]                         is.null <- base::is.null
  [03:00:27.409]                         restarts <- computeRestarts(cond)
  [03:00:27.409]                         for (restart in restarts) {
  [03:00:27.409]                           name <- restart$name
  [03:00:27.409]                           if (is.null(name)) 
  [03:00:27.409]                             next
  [03:00:27.409]                           if (!grepl("^muffle", name)) 
  [03:00:27.409]                             next
  [03:00:27.409]                           invokeRestart(restart)
  [03:00:27.409]                           muffled <- TRUE
  [03:00:27.409]                           break
  [03:00:27.409]                         }
  [03:00:27.409]                       }
  [03:00:27.409]                       invisible(muffled)
  [03:00:27.409]                     }
  [03:00:27.409]                     muffleCondition(cond)
  [03:00:27.409]                   }
  [03:00:27.409]                 }
  [03:00:27.409]             }
  [03:00:27.409]         }))
  [03:00:27.409]     }, error = function(ex) {
  [03:00:27.409]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:27.409]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.409]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:27.409]     }, finally = {
  [03:00:27.409]         {
  [03:00:27.409]             NULL
  [03:00:27.409]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:27.409]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:27.409]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:27.409]                 label = NULL, ...) 
  [03:00:27.409]             {
  [03:00:27.409]                 if (substitute) 
  [03:00:27.409]                   expr <- substitute(expr)
  [03:00:27.409]                 local <- as.logical(local)
  [03:00:27.409]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:27.409]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:27.409]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:27.409]                   label = label, ...)
  [03:00:27.409]                 if (!future$lazy) 
  [03:00:27.409]                   future <- run(future)
  [03:00:27.409]                 invisible(future)
  [03:00:27.409]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:27.409]         }
  [03:00:27.409]         base::options(...future.oldOptions)
  [03:00:27.409]     })
  [03:00:27.409]     Sys.time
  [03:00:27.409]     if (base::is.na(TRUE)) {
  [03:00:27.409]     }
  [03:00:27.409]     else {
  [03:00:27.409]         base::sink(type = "output", split = FALSE)
  [03:00:27.409]         if (TRUE) {
  [03:00:27.409]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:27.409]         }
  [03:00:27.409]         else {
  [03:00:27.409]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:27.409]         }
  [03:00:27.409]         base::close(...future.stdout)
  [03:00:27.409]         ...future.stdout <- NULL
  [03:00:27.409]     }
  [03:00:27.409]     ...future.result$conditions <- ...future.conditions
  [03:00:27.409]     ...future.result
  [03:00:27.409] }
  [03:00:27.417] plan(): Setting new future strategy stack:
  [03:00:27.417] List of future strategies:
  [03:00:27.417] 1. sequential:
  [03:00:27.417]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.417]    - tweaked: FALSE
  [03:00:27.417]    - call: NULL
  [03:00:27.419] plan(): nbrOfWorkers() = 1
  [03:00:27.427] plan(): Setting new future strategy stack:
  [03:00:27.428] List of future strategies:
  [03:00:27.428] 1. sequential:
  [03:00:27.428]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.428]    - tweaked: FALSE
  [03:00:27.428]    - call: plan(strategy)
  [03:00:27.429] plan(): nbrOfWorkers() = 1
  [03:00:27.430] SequentialFuture started (and completed)
  [03:00:27.430] signalConditions() ...
  [03:00:27.431]  - include = 'immediateCondition'
  [03:00:27.431]  - exclude = 
  [03:00:27.432]  - resignal = FALSE
  [03:00:27.432]  - Number of conditions: 2
  [03:00:27.433] signalConditions() ... done
  Plotting tile #2 of 4 ...
  [03:00:27.434] signalConditions() ...
  [03:00:27.434]  - include = 'immediateCondition'
  [03:00:27.434]  - exclude = 
  [03:00:27.435]  - resignal = FALSE
  [03:00:27.435]  - Number of conditions: 2
  [03:00:27.436] signalConditions() ... done
  [03:00:27.436] Future state: 'finished'
  [03:00:27.437] signalConditions() ...
  [03:00:27.437]  - include = 'condition'
  [03:00:27.437]  - exclude = 'immediateCondition'
  [03:00:27.438]  - resignal = TRUE
  [03:00:27.438]  - Number of conditions: 2
  [03:00:27.439]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #2 of 4 ...[03:00:27.439]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [03:00:27.440] signalConditions() ... done
  [03:00:27.444] Packages needed by the future expression (n = 1): 'future'
  [03:00:27.445] Packages needed by future strategies (n = 0): <none>
  [03:00:27.459] {
  [03:00:27.459]     {
  [03:00:27.459]         ...future.startTime <- base::Sys.time()
  [03:00:27.459]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:27.459]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:27.459]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:27.459]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:27.459]             future.resolve.recursive = NULL, width = 80L)
  [03:00:27.459]         {
  [03:00:27.459]             {
  [03:00:27.459]                 {
  [03:00:27.459]                   base::local({
  [03:00:27.459]                     has_future <- base::requireNamespace("future", 
  [03:00:27.459]                       quietly = TRUE)
  [03:00:27.459]                     version <- if (has_future) 
  [03:00:27.459]                       utils::packageVersion("future")
  [03:00:27.459]                     else NULL
  [03:00:27.459]                     if (!has_future || version < "1.8.0") {
  [03:00:27.459]                       info <- base::c(r_version = base::gsub("R version ", 
  [03:00:27.459]                         "", base::R.version$version.string), 
  [03:00:27.459]                         platform = base::sprintf("%s (%s-bit)", 
  [03:00:27.459]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:27.459]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:27.459]                           "release", "version")], collapse = " "), 
  [03:00:27.459]                         hostname = base::Sys.info()[["nodename"]])
  [03:00:27.459]                       info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:27.459]                         info)
  [03:00:27.459]                       info <- base::paste(info, collapse = "; ")
  [03:00:27.459]                       if (!has_future) {
  [03:00:27.459]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:27.459]                           info)
  [03:00:27.459]                       }
  [03:00:27.459]                       else {
  [03:00:27.459]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:27.459]                           info, version)
  [03:00:27.459]                       }
  [03:00:27.459]                       base::stop(msg)
  [03:00:27.459]                     }
  [03:00:27.459]                   })
  [03:00:27.459]                 }
  [03:00:27.459]                 base::local({
  [03:00:27.459]                   for (pkg in "future") {
  [03:00:27.459]                     base::loadNamespace(pkg)
  [03:00:27.459]                     base::library(pkg, character.only = TRUE)
  [03:00:27.459]                   }
  [03:00:27.459]                 })
  [03:00:27.459]             }
  [03:00:27.459]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:27.459]         }
  [03:00:27.459]     }
  [03:00:27.459]     if (base::is.na(TRUE)) {
  [03:00:27.459]     }
  [03:00:27.459]     else {
  [03:00:27.459]         if (TRUE) {
  [03:00:27.459]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:27.459]                 open = "w")
  [03:00:27.459]         }
  [03:00:27.459]         else {
  [03:00:27.459]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:27.459]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:27.459]         }
  [03:00:27.459]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:27.459]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:27.459]             base::sink(type = "output", split = FALSE)
  [03:00:27.459]             base::close(...future.stdout)
  [03:00:27.459]         }, add = TRUE)
  [03:00:27.459]     }
  [03:00:27.459]     ...future.frame <- base::sys.nframe()
  [03:00:27.459]     ...future.conditions <- base::list()
  [03:00:27.459]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:27.459]     ...future.result <- base::tryCatch({
  [03:00:27.459]         base::withCallingHandlers({
  [03:00:27.459]             ...future.value <- base::withVisible(base::local({
  [03:00:27.459]                 message(sprintf("Calculating tile #%d of %d ...", 
  [03:00:27.459]                   ii, n), appendLF = FALSE)
  [03:00:27.459]                 fit <- mandelbrot(C)
  [03:00:27.459]                 delay(fit)
  [03:00:27.459]                 message(" done")
  [03:00:27.459]                 fit
  [03:00:27.459]             }))
  [03:00:27.459]             future::FutureResult(value = ...future.value$value, 
  [03:00:27.459]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.459]                   ...future.rng), started = ...future.startTime, 
  [03:00:27.459]                 version = "1.8")
  [03:00:27.459]         }, condition = base::local({
  [03:00:27.459]             c <- base::c
  [03:00:27.459]             inherits <- base::inherits
  [03:00:27.459]             invokeRestart <- base::invokeRestart
  [03:00:27.459]             length <- base::length
  [03:00:27.459]             list <- base::list
  [03:00:27.459]             seq.int <- base::seq.int
  [03:00:27.459]             signalCondition <- base::signalCondition
  [03:00:27.459]             sys.calls <- base::sys.calls
  [03:00:27.459]             Sys.time <- base::Sys.time
  [03:00:27.459]             `[[` <- base::`[[`
  [03:00:27.459]             `+` <- base::`+`
  [03:00:27.459]             `<<-` <- base::`<<-`
  [03:00:27.459]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:27.459]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:27.459]                   3L)]
  [03:00:27.459]             }
  [03:00:27.459]             function(cond) {
  [03:00:27.459]                 if (inherits(cond, "error")) {
  [03:00:27.459]                   sessionInformation <- function() {
  [03:00:27.459]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:27.459]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:27.459]                       search = base::search(), system = base::Sys.info())
  [03:00:27.459]                   }
  [03:00:27.459]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.459]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:27.459]                     cond$call), session = sessionInformation(), 
  [03:00:27.459]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:27.459]                   signalCondition(cond)
  [03:00:27.459]                 }
  [03:00:27.459]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:00:27.459]                 ))) {
  [03:00:27.459]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:27.459]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.459]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:27.459]                   if (!signal) {
  [03:00:27.459]                     muffleCondition <- function (cond) 
  [03:00:27.459]                     {
  [03:00:27.459]                       inherits <- base::inherits
  [03:00:27.459]                       invokeRestart <- base::invokeRestart
  [03:00:27.459]                       muffled <- FALSE
  [03:00:27.459]                       if (inherits(cond, "message")) {
  [03:00:27.459]                         invokeRestart("muffleMessage")
  [03:00:27.459]                         muffled <- TRUE
  [03:00:27.459]                       }
  [03:00:27.459]                       else if (inherits(cond, "warning")) {
  [03:00:27.459]                         invokeRestart("muffleWarning")
  [03:00:27.459]                         muffled <- TRUE
  [03:00:27.459]                       }
  [03:00:27.459]                       else if (inherits(cond, "condition")) {
  [03:00:27.459]                         computeRestarts <- base::computeRestarts
  [03:00:27.459]                         grepl <- base::grepl
  [03:00:27.459]                         is.null <- base::is.null
  [03:00:27.459]                         restarts <- computeRestarts(cond)
  [03:00:27.459]                         for (restart in restarts) {
  [03:00:27.459]                           name <- restart$name
  [03:00:27.459]                           if (is.null(name)) 
  [03:00:27.459]                             next
  [03:00:27.459]                           if (!grepl("^muffle", name)) 
  [03:00:27.459]                             next
  [03:00:27.459]                           invokeRestart(restart)
  [03:00:27.459]                           muffled <- TRUE
  [03:00:27.459]                           break
  [03:00:27.459]                         }
  [03:00:27.459]                       }
  [03:00:27.459]                       invisible(muffled)
  [03:00:27.459]                     }
  [03:00:27.459]                     muffleCondition(cond)
  [03:00:27.459]                   }
  [03:00:27.459]                 }
  [03:00:27.459]             }
  [03:00:27.459]         }))
  [03:00:27.459]     }, error = function(ex) {
  [03:00:27.459]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:27.459]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.459]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:27.459]     }, finally = {
  [03:00:27.459]         {
  [03:00:27.459]             NULL
  [03:00:27.459]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:27.459]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:27.459]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:27.459]                 label = NULL, ...) 
  [03:00:27.459]             {
  [03:00:27.459]                 if (substitute) 
  [03:00:27.459]                   expr <- substitute(expr)
  [03:00:27.459]                 local <- as.logical(local)
  [03:00:27.459]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:27.459]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:27.459]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:27.459]                   label = label, ...)
  [03:00:27.459]                 if (!future$lazy) 
  [03:00:27.459]                   future <- run(future)
  [03:00:27.459]                 invisible(future)
  [03:00:27.459]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:27.459]         }
  [03:00:27.459]         base::options(...future.oldOptions)
  [03:00:27.459]     })
  [03:00:27.459]     Sys.time
  [03:00:27.459]     if (base::is.na(TRUE)) {
  [03:00:27.459]     }
  [03:00:27.459]     else {
  [03:00:27.459]         base::sink(type = "output", split = FALSE)
  [03:00:27.459]         if (TRUE) {
  [03:00:27.459]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:27.459]         }
  [03:00:27.459]         else {
  [03:00:27.459]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:27.459]         }
  [03:00:27.459]         base::close(...future.stdout)
  [03:00:27.459]         ...future.stdout <- NULL
  [03:00:27.459]     }
  [03:00:27.459]     ...future.result$conditions <- ...future.conditions
  [03:00:27.459]     ...future.result
  [03:00:27.459] }
  [03:00:27.467] plan(): Setting new future strategy stack:
  [03:00:27.468] List of future strategies:
  [03:00:27.468] 1. sequential:
  [03:00:27.468]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.468]    - tweaked: FALSE
  [03:00:27.468]    - call: NULL
  [03:00:27.470] plan(): nbrOfWorkers() = 1
  [03:00:27.474] plan(): Setting new future strategy stack:
  [03:00:27.475] List of future strategies:
  [03:00:27.475] 1. sequential:
  [03:00:27.475]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.475]    - tweaked: FALSE
  [03:00:27.475]    - call: plan(strategy)
  [03:00:27.477] plan(): nbrOfWorkers() = 1
  [03:00:27.478] SequentialFuture started (and completed)
  [03:00:27.478] signalConditions() ...
  [03:00:27.479]  - include = 'immediateCondition'
  [03:00:27.479]  - exclude = 
  [03:00:27.480]  - resignal = FALSE
  [03:00:27.480]  - Number of conditions: 2
  [03:00:27.481] signalConditions() ... done
  Plotting tile #3 of 4 ...
  [03:00:27.482] signalConditions() ...
  [03:00:27.482]  - include = 'immediateCondition'
  [03:00:27.483]  - exclude = 
  [03:00:27.483]  - resignal = FALSE
  [03:00:27.484]  - Number of conditions: 2
  [03:00:27.484] signalConditions() ... done
  [03:00:27.485] Future state: 'finished'
  [03:00:27.485] signalConditions() ...
  [03:00:27.486]  - include = 'condition'
  [03:00:27.486]  - exclude = 'immediateCondition'
  [03:00:27.487]  - resignal = TRUE
  [03:00:27.487]  - Number of conditions: 2
  [03:00:27.487]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #3 of 4 ...[03:00:27.488]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [03:00:27.489] signalConditions() ... done
  [03:00:27.493] Packages needed by the future expression (n = 1): 'future'
  [03:00:27.494] Packages needed by future strategies (n = 0): <none>
  [03:00:27.501] {
  [03:00:27.501]     {
  [03:00:27.501]         ...future.startTime <- base::Sys.time()
  [03:00:27.501]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:27.501]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:27.501]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:27.501]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:27.501]             future.resolve.recursive = NULL, width = 80L)
  [03:00:27.501]         {
  [03:00:27.501]             {
  [03:00:27.501]                 {
  [03:00:27.501]                   base::local({
  [03:00:27.501]                     has_future <- base::requireNamespace("future", 
  [03:00:27.501]                       quietly = TRUE)
  [03:00:27.501]                     version <- if (has_future) 
  [03:00:27.501]                       utils::packageVersion("future")
  [03:00:27.501]                     else NULL
  [03:00:27.501]                     if (!has_future || version < "1.8.0") {
  [03:00:27.501]                       info <- base::c(r_version = base::gsub("R version ", 
  [03:00:27.501]                         "", base::R.version$version.string), 
  [03:00:27.501]                         platform = base::sprintf("%s (%s-bit)", 
  [03:00:27.501]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:27.501]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:27.501]                           "release", "version")], collapse = " "), 
  [03:00:27.501]                         hostname = base::Sys.info()[["nodename"]])
  [03:00:27.501]                       info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:27.501]                         info)
  [03:00:27.501]                       info <- base::paste(info, collapse = "; ")
  [03:00:27.501]                       if (!has_future) {
  [03:00:27.501]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:27.501]                           info)
  [03:00:27.501]                       }
  [03:00:27.501]                       else {
  [03:00:27.501]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:27.501]                           info, version)
  [03:00:27.501]                       }
  [03:00:27.501]                       base::stop(msg)
  [03:00:27.501]                     }
  [03:00:27.501]                   })
  [03:00:27.501]                 }
  [03:00:27.501]                 base::local({
  [03:00:27.501]                   for (pkg in "future") {
  [03:00:27.501]                     base::loadNamespace(pkg)
  [03:00:27.501]                     base::library(pkg, character.only = TRUE)
  [03:00:27.501]                   }
  [03:00:27.501]                 })
  [03:00:27.501]             }
  [03:00:27.501]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:27.501]         }
  [03:00:27.501]     }
  [03:00:27.501]     if (base::is.na(TRUE)) {
  [03:00:27.501]     }
  [03:00:27.501]     else {
  [03:00:27.501]         if (TRUE) {
  [03:00:27.501]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:27.501]                 open = "w")
  [03:00:27.501]         }
  [03:00:27.501]         else {
  [03:00:27.501]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:27.501]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:27.501]         }
  [03:00:27.501]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:27.501]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:27.501]             base::sink(type = "output", split = FALSE)
  [03:00:27.501]             base::close(...future.stdout)
  [03:00:27.501]         }, add = TRUE)
  [03:00:27.501]     }
  [03:00:27.501]     ...future.frame <- base::sys.nframe()
  [03:00:27.501]     ...future.conditions <- base::list()
  [03:00:27.501]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:27.501]     ...future.result <- base::tryCatch({
  [03:00:27.501]         base::withCallingHandlers({
  [03:00:27.501]             ...future.value <- base::withVisible(base::local({
  [03:00:27.501]                 message(sprintf("Calculating tile #%d of %d ...", 
  [03:00:27.501]                   ii, n), appendLF = FALSE)
  [03:00:27.501]                 fit <- mandelbrot(C)
  [03:00:27.501]                 delay(fit)
  [03:00:27.501]                 message(" done")
  [03:00:27.501]                 fit
  [03:00:27.501]             }))
  [03:00:27.501]             future::FutureResult(value = ...future.value$value, 
  [03:00:27.501]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.501]                   ...future.rng), started = ...future.startTime, 
  [03:00:27.501]                 version = "1.8")
  [03:00:27.501]         }, condition = base::local({
  [03:00:27.501]             c <- base::c
  [03:00:27.501]             inherits <- base::inherits
  [03:00:27.501]             invokeRestart <- base::invokeRestart
  [03:00:27.501]             length <- base::length
  [03:00:27.501]             list <- base::list
  [03:00:27.501]             seq.int <- base::seq.int
  [03:00:27.501]             signalCondition <- base::signalCondition
  [03:00:27.501]             sys.calls <- base::sys.calls
  [03:00:27.501]             Sys.time <- base::Sys.time
  [03:00:27.501]             `[[` <- base::`[[`
  [03:00:27.501]             `+` <- base::`+`
  [03:00:27.501]             `<<-` <- base::`<<-`
  [03:00:27.501]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:27.501]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:27.501]                   3L)]
  [03:00:27.501]             }
  [03:00:27.501]             function(cond) {
  [03:00:27.501]                 if (inherits(cond, "error")) {
  [03:00:27.501]                   sessionInformation <- function() {
  [03:00:27.501]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:27.501]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:27.501]                       search = base::search(), system = base::Sys.info())
  [03:00:27.501]                   }
  [03:00:27.501]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.501]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:27.501]                     cond$call), session = sessionInformation(), 
  [03:00:27.501]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:27.501]                   signalCondition(cond)
  [03:00:27.501]                 }
  [03:00:27.501]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:00:27.501]                 ))) {
  [03:00:27.501]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:00:27.501]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.501]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:27.501]                   if (!signal) {
  [03:00:27.501]                     muffleCondition <- function (cond) 
  [03:00:27.501]                     {
  [03:00:27.501]                       inherits <- base::inherits
  [03:00:27.501]                       invokeRestart <- base::invokeRestart
  [03:00:27.501]                       muffled <- FALSE
  [03:00:27.501]                       if (inherits(cond, "message")) {
  [03:00:27.501]                         invokeRestart("muffleMessage")
  [03:00:27.501]                         muffled <- TRUE
  [03:00:27.501]                       }
  [03:00:27.501]                       else if (inherits(cond, "warning")) {
  [03:00:27.501]                         invokeRestart("muffleWarning")
  [03:00:27.501]                         muffled <- TRUE
  [03:00:27.501]                       }
  [03:00:27.501]                       else if (inherits(cond, "condition")) {
  [03:00:27.501]                         computeRestarts <- base::computeRestarts
  [03:00:27.501]                         grepl <- base::grepl
  [03:00:27.501]                         is.null <- base::is.null
  [03:00:27.501]                         restarts <- computeRestarts(cond)
  [03:00:27.501]                         for (restart in restarts) {
  [03:00:27.501]                           name <- restart$name
  [03:00:27.501]                           if (is.null(name)) 
  [03:00:27.501]                             next
  [03:00:27.501]                           if (!grepl("^muffle", name)) 
  [03:00:27.501]                             next
  [03:00:27.501]                           invokeRestart(restart)
  [03:00:27.501]                           muffled <- TRUE
  [03:00:27.501]                           break
  [03:00:27.501]                         }
  [03:00:27.501]                       }
  [03:00:27.501]                       invisible(muffled)
  [03:00:27.501]                     }
  [03:00:27.501]                     muffleCondition(cond)
  [03:00:27.501]                   }
  [03:00:27.501]                 }
  [03:00:27.501]             }
  [03:00:27.501]         }))
  [03:00:27.501]     }, error = function(ex) {
  [03:00:27.501]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:27.501]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.501]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:27.501]     }, finally = {
  [03:00:27.501]         {
  [03:00:27.501]             NULL
  [03:00:27.501]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:27.501]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:27.501]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:00:27.501]                 label = NULL, ...) 
  [03:00:27.501]             {
  [03:00:27.501]                 if (substitute) 
  [03:00:27.501]                   expr <- substitute(expr)
  [03:00:27.501]                 local <- as.logical(local)
  [03:00:27.501]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:00:27.501]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:27.501]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:00:27.501]                   label = label, ...)
  [03:00:27.501]                 if (!future$lazy) 
  [03:00:27.501]                   future <- run(future)
  [03:00:27.501]                 invisible(future)
  [03:00:27.501]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:27.501]         }
  [03:00:27.501]         base::options(...future.oldOptions)
  [03:00:27.501]     })
  [03:00:27.501]     Sys.time
  [03:00:27.501]     if (base::is.na(TRUE)) {
  [03:00:27.501]     }
  [03:00:27.501]     else {
  [03:00:27.501]         base::sink(type = "output", split = FALSE)
  [03:00:27.501]         if (TRUE) {
  [03:00:27.501]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:27.501]         }
  [03:00:27.501]         else {
  [03:00:27.501]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:27.501]         }
  [03:00:27.501]         base::close(...future.stdout)
  [03:00:27.501]         ...future.stdout <- NULL
  [03:00:27.501]     }
  [03:00:27.501]     ...future.result$conditions <- ...future.conditions
  [03:00:27.501]     ...future.result
  [03:00:27.501] }
  [03:00:27.509] plan(): Setting new future strategy stack:
  [03:00:27.509] List of future strategies:
  [03:00:27.509] 1. sequential:
  [03:00:27.509]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.509]    - tweaked: FALSE
  [03:00:27.509]    - call: NULL
  [03:00:27.510] plan(): nbrOfWorkers() = 1
  [03:00:27.517] plan(): Setting new future strategy stack:
  [03:00:27.518] List of future strategies:
  [03:00:27.518] 1. sequential:
  [03:00:27.518]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.518]    - tweaked: FALSE
  [03:00:27.518]    - call: plan(strategy)
  [03:00:27.520] plan(): nbrOfWorkers() = 1
  [03:00:27.521] SequentialFuture started (and completed)
  [03:00:27.521] signalConditions() ...
  [03:00:27.522]  - include = 'immediateCondition'
  [03:00:27.522]  - exclude = 
  [03:00:27.523]  - resignal = FALSE
  [03:00:27.523]  - Number of conditions: 2
  [03:00:27.524] signalConditions() ... done
  Plotting tile #4 of 4 ...
  [03:00:27.524] signalConditions() ...
  [03:00:27.525]  - include = 'immediateCondition'
  [03:00:27.525]  - exclude = 
  [03:00:27.526]  - resignal = FALSE
  [03:00:27.526]  - Number of conditions: 2
  [03:00:27.526] signalConditions() ... done
  [03:00:27.527] Future state: 'finished'
  [03:00:27.527] signalConditions() ...
  [03:00:27.528]  - include = 'condition'
  [03:00:27.528]  - exclude = 'immediateCondition'
  [03:00:27.528]  - resignal = TRUE
  [03:00:27.529]  - Number of conditions: 2
  [03:00:27.529]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #4 of 4 ...[03:00:27.530]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [03:00:27.530] signalConditions() ... done
  
  > close.screen()
  [1] 1 2 3 4
  
  > message("SUGGESTION: Try to rerun this demo after changing strategy for how futures are resolved, e.g. plan(multiprocess).\n")
  SUGGESTION: Try to rerun this demo after changing strategy for how futures are resolved, e.g. plan(multiprocess).
  
  - plan('sequential') ... DONE
  Testing with 1 cores ... DONE
  Testing with 2 cores ...
  - plan('multicore') ...
  [03:00:27.554] plan(): Setting new future strategy stack:
  [03:00:27.555] List of future strategies:
  [03:00:27.555] 1. multicore:
  [03:00:27.555]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [03:00:27.555]    - tweaked: FALSE
  [03:00:27.555]    - call: plan(strategy)
  [03:00:27.557] plan(): nbrOfWorkers() = 2
  
  
  	demo(mandelbrot)
  	---- ~~~~~~~~~~
  
  > library("future")
  
  > library("graphics")
  
  > plot_what_is_done <- function(counts) {
  +   for (kk in seq_along(counts)) {
  +     f <- counts[[kk]]
  + 
  +     ## Already plotted?
  +     if (!inherits(f, "Future")) next
  + 
  +     ## Not resolved?
  +     if (!resolved(f)) next
  + 
  +     message(sprintf("Plotting tile #%d of %d ...", kk, n))
  +     counts[[kk]] <- value(f)
  +     screen(kk)
  +     plot(counts[[kk]])
  +   }
  + 
  +   counts
  + }
  
  > ## Options
  > region <- getOption("future.demo.mandelbrot.region", 1L)
  
  > if (!is.list(region)) {
  +   if (region == 1L) {
  +     region <- list(xmid = -0.75, ymid = 0.0, side = 3.0)
  +   } else if (region == 2L) {
  +     region <- list(xmid = 0.283, ymid = -0.0095, side = 0.00026)
  +   } else if (region == 3L) {
  +     region <- list(xmid = 0.282989, ymid = -0.01, side = 3e-8)
  +   }
  + }
  
  > nrow <- getOption("future.demo.mandelbrot.nrow", 3L)
  
  > resolution <- getOption("future.demo.mandelbrot.resolution", 400L)
  
  > delay <- getOption("future.demo.mandelbrot.delay", interactive())
  
  > if (isTRUE(delay)) {
  +   delay <- function(counts) Sys.sleep(rexp(1, rate = 2))
  + } else if (!is.function(delay)) {
  +   delay <- function(counts) {}
  + }
  
  > ## Generate Mandelbrot tiles to be computed
  > Cs <- mandelbrot_tiles(xmid = region$xmid, ymid = region$ymid,
  +                        side = region$side, nrow = nrow,
  +                        resolution = resolution)
  
  > if (interactive()) {
  +   dev.new()
  +   plot.new()
  +   split.screen(dim(Cs))
  +   for (ii in seq_along(Cs)) {
  +     screen(ii)
  +     par(mar = c(0, 0, 0, 0))
  +     text(x = 1 / 2, y = 1 / 2, sprintf("Future #%d\nunresolved", ii), cex = 2)
  +   }
  + } else {
  +   split.screen(dim(Cs))
  + }
  [1] 5 6 7 8
  
  > ## Create all Mandelbrot tiles via lazy futures
  > n <- length(Cs)
  
  > message(sprintf("Creating %d Mandelbrot tiles:", n), appendLF = FALSE)
  Creating 4 Mandelbrot tiles:
  > counts <- lapply(seq_along(Cs), FUN=function(ii) {
  +   message(" ", ii, appendLF = FALSE)
  +   C <- Cs[[ii]]
  +   future({
  +     message(sprintf("Calculating tile #%d of %d ...", ii, n), appendLF = FALSE)
  +     fit <- mandelbrot(C)
  + 
  +     ## Emulate slowness
  +     delay(fit)
  + 
  +     message(" done")
  +     fit
  +   }, lazy = TRUE)
  + })
   1[03:00:27.570] getGlobalsAndPackages() ...
  [03:00:27.571] Searching for globals...
  [03:00:27.581] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [03:00:27.581] Searching for globals ... DONE
  [03:00:27.582] Resolving globals: FALSE
  [03:00:27.584] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [03:00:27.584] - globals: [4] 'ii', 'n', 'C', 'delay'
  [03:00:27.585] - packages: [1] 'future'
  [03:00:27.585] getGlobalsAndPackages() ... DONE
   2[03:00:27.600] getGlobalsAndPackages() ...
  [03:00:27.601] Searching for globals...
  [03:00:27.609] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [03:00:27.609] Searching for globals ... DONE
  [03:00:27.610] Resolving globals: FALSE
  [03:00:27.612] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [03:00:27.612] - globals: [4] 'ii', 'n', 'C', 'delay'
  [03:00:27.613] - packages: [1] 'future'
  [03:00:27.613] getGlobalsAndPackages() ... DONE
   3[03:00:27.615] getGlobalsAndPackages() ...
  [03:00:27.615] Searching for globals...
  [03:00:27.624] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [03:00:27.624] Searching for globals ... DONE
  [03:00:27.625] Resolving globals: FALSE
  [03:00:27.627] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [03:00:27.627] - globals: [4] 'ii', 'n', 'C', 'delay'
  [03:00:27.628] - packages: [1] 'future'
  [03:00:27.628] getGlobalsAndPackages() ... DONE
   4[03:00:27.635] getGlobalsAndPackages() ...
  [03:00:27.636] Searching for globals...
  [03:00:27.645] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [03:00:27.646] Searching for globals ... DONE
  [03:00:27.646] Resolving globals: FALSE
  [03:00:27.648] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [03:00:27.649] - globals: [4] 'ii', 'n', 'C', 'delay'
  [03:00:27.650] - packages: [1] 'future'
  [03:00:27.650] getGlobalsAndPackages() ... DONE
  
  > message(".")
  .
  
  > ## Calculate and plot tiles
  > repeat {
  +   counts <- plot_what_is_done(counts)
  +   if (!any(sapply(counts, FUN = inherits, "Future"))) break
  + }
  [03:00:27.687] Packages needed by the future expression (n = 0): <none>
  [03:00:27.688] Packages needed by future strategies (n = 0): <none>
  [03:00:27.695] {
  [03:00:27.695]     {
  [03:00:27.695]         ...future.startTime <- base::Sys.time()
  [03:00:27.695]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:27.695]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:27.695]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:27.695]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:27.695]             future.resolve.recursive = NULL, width = 80L)
  [03:00:27.695]         {
  [03:00:27.695]             {
  [03:00:27.695]                 {
  [03:00:27.695]                   base::local({
  [03:00:27.695]                     has_future <- base::requireNamespace("future", 
  [03:00:27.695]                       quietly = TRUE)
  [03:00:27.695]                     version <- if (has_future) 
  [03:00:27.695]                       utils::packageVersion("future")
  [03:00:27.695]                     else NULL
  [03:00:27.695]                     if (!has_future || version < "1.8.0") {
  [03:00:27.695]                       info <- base::c(r_version = base::gsub("R version ", 
  [03:00:27.695]                         "", base::R.version$version.string), 
  [03:00:27.695]                         platform = base::sprintf("%s (%s-bit)", 
  [03:00:27.695]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:27.695]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:27.695]                           "release", "version")], collapse = " "), 
  [03:00:27.695]                         hostname = base::Sys.info()[["nodename"]])
  [03:00:27.695]                       info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:27.695]                         info)
  [03:00:27.695]                       info <- base::paste(info, collapse = "; ")
  [03:00:27.695]                       if (!has_future) {
  [03:00:27.695]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:27.695]                           info)
  [03:00:27.695]                       }
  [03:00:27.695]                       else {
  [03:00:27.695]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:27.695]                           info, version)
  [03:00:27.695]                       }
  [03:00:27.695]                       base::stop(msg)
  [03:00:27.695]                     }
  [03:00:27.695]                   })
  [03:00:27.695]                 }
  [03:00:27.695]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [03:00:27.695]                 base::options(mc.cores = 1L)
  [03:00:27.695]             }
  [03:00:27.695]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:27.695]         }
  [03:00:27.695]     }
  [03:00:27.695]     if (base::is.na(TRUE)) {
  [03:00:27.695]     }
  [03:00:27.695]     else {
  [03:00:27.695]         if (TRUE) {
  [03:00:27.695]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:27.695]                 open = "w")
  [03:00:27.695]         }
  [03:00:27.695]         else {
  [03:00:27.695]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:27.695]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:27.695]         }
  [03:00:27.695]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:27.695]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:27.695]             base::sink(type = "output", split = FALSE)
  [03:00:27.695]             base::close(...future.stdout)
  [03:00:27.695]         }, add = TRUE)
  [03:00:27.695]     }
  [03:00:27.695]     ...future.frame <- base::sys.nframe()
  [03:00:27.695]     ...future.conditions <- base::list()
  [03:00:27.695]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:27.695]     ...future.result <- base::tryCatch({
  [03:00:27.695]         base::withCallingHandlers({
  [03:00:27.695]             ...future.value <- base::withVisible(base::local({
  [03:00:27.695]                 message(sprintf("Calculating tile #%d of %d ...", 
  [03:00:27.695]                   ii, n), appendLF = FALSE)
  [03:00:27.695]                 fit <- mandelbrot(C)
  [03:00:27.695]                 delay(fit)
  [03:00:27.695]                 message(" done")
  [03:00:27.695]                 fit
  [03:00:27.695]             }))
  [03:00:27.695]             future::FutureResult(value = ...future.value$value, 
  [03:00:27.695]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.695]                   ...future.rng), started = ...future.startTime, 
  [03:00:27.695]                 version = "1.8")
  [03:00:27.695]         }, condition = base::local({
  [03:00:27.695]             c <- base::c
  [03:00:27.695]             inherits <- base::inherits
  [03:00:27.695]             invokeRestart <- base::invokeRestart
  [03:00:27.695]             length <- base::length
  [03:00:27.695]             list <- base::list
  [03:00:27.695]             seq.int <- base::seq.int
  [03:00:27.695]             signalCondition <- base::signalCondition
  [03:00:27.695]             sys.calls <- base::sys.calls
  [03:00:27.695]             Sys.time <- base::Sys.time
  [03:00:27.695]             `[[` <- base::`[[`
  [03:00:27.695]             `+` <- base::`+`
  [03:00:27.695]             `<<-` <- base::`<<-`
  [03:00:27.695]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:27.695]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:27.695]                   3L)]
  [03:00:27.695]             }
  [03:00:27.695]             function(cond) {
  [03:00:27.695]                 if (inherits(cond, "error")) {
  [03:00:27.695]                   sessionInformation <- function() {
  [03:00:27.695]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:27.695]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:27.695]                       search = base::search(), system = base::Sys.info())
  [03:00:27.695]                   }
  [03:00:27.695]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.695]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:27.695]                     cond$call), session = sessionInformation(), 
  [03:00:27.695]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:27.695]                   signalCondition(cond)
  [03:00:27.695]                 }
  [03:00:27.695]                 else if (inherits(cond, "condition")) {
  [03:00:27.695]                   signal <- FALSE && inherits(cond, character(0))
  [03:00:27.695]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.695]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:27.695]                   if (!signal) {
  [03:00:27.695]                     muffleCondition <- function (cond) 
  [03:00:27.695]                     {
  [03:00:27.695]                       inherits <- base::inherits
  [03:00:27.695]                       invokeRestart <- base::invokeRestart
  [03:00:27.695]                       muffled <- FALSE
  [03:00:27.695]                       if (inherits(cond, "message")) {
  [03:00:27.695]                         invokeRestart("muffleMessage")
  [03:00:27.695]                         muffled <- TRUE
  [03:00:27.695]                       }
  [03:00:27.695]                       else if (inherits(cond, "warning")) {
  [03:00:27.695]                         invokeRestart("muffleWarning")
  [03:00:27.695]                         muffled <- TRUE
  [03:00:27.695]                       }
  [03:00:27.695]                       else if (inherits(cond, "condition")) {
  [03:00:27.695]                         computeRestarts <- base::computeRestarts
  [03:00:27.695]                         grepl <- base::grepl
  [03:00:27.695]                         is.null <- base::is.null
  [03:00:27.695]                         restarts <- computeRestarts(cond)
  [03:00:27.695]                         for (restart in restarts) {
  [03:00:27.695]                           name <- restart$name
  [03:00:27.695]                           if (is.null(name)) 
  [03:00:27.695]                             next
  [03:00:27.695]                           if (!grepl("^muffle", name)) 
  [03:00:27.695]                             next
  [03:00:27.695]                           invokeRestart(restart)
  [03:00:27.695]                           muffled <- TRUE
  [03:00:27.695]                           break
  [03:00:27.695]                         }
  [03:00:27.695]                       }
  [03:00:27.695]                       invisible(muffled)
  [03:00:27.695]                     }
  [03:00:27.695]                     muffleCondition(cond)
  [03:00:27.695]                   }
  [03:00:27.695]                 }
  [03:00:27.695]             }
  [03:00:27.695]         }))
  [03:00:27.695]     }, error = function(ex) {
  [03:00:27.695]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:27.695]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.695]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:27.695]     }, finally = {
  [03:00:27.695]         {
  [03:00:27.695]             {
  [03:00:27.695]                 base::options(mc.cores = ...future.mc.cores.old)
  [03:00:27.695]             }
  [03:00:27.695]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:27.695]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:27.695]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [03:00:27.695]                 earlySignal = FALSE, label = NULL, ...) 
  [03:00:27.695]             {
  [03:00:27.695]                 if (substitute) 
  [03:00:27.695]                   expr <- substitute(expr)
  [03:00:27.695]                 if (is.function(workers)) 
  [03:00:27.695]                   workers <- workers()
  [03:00:27.695]                 workers <- as.integer(workers)
  [03:00:27.695]                 stop_if_not(is.finite(workers), workers >= 1L)
  [03:00:27.695]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [03:00:27.695]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [03:00:27.695]                     lazy = lazy, seed = seed, globals = globals, 
  [03:00:27.695]                     local = TRUE, label = label, ...))
  [03:00:27.695]                 }
  [03:00:27.695]                 oopts <- options(mc.cores = workers)
  [03:00:27.695]                 on.exit(options(oopts))
  [03:00:27.695]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [03:00:27.695]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:27.695]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [03:00:27.695]                   label = label, ...)
  [03:00:27.695]                 if (!future$lazy) 
  [03:00:27.695]                   future <- run(future)
  [03:00:27.695]                 invisible(future)
  [03:00:27.695]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:27.695]         }
  [03:00:27.695]         base::options(...future.oldOptions)
  [03:00:27.695]     })
  [03:00:27.695]     Sys.time
  [03:00:27.695]     if (base::is.na(TRUE)) {
  [03:00:27.695]     }
  [03:00:27.695]     else {
  [03:00:27.695]         base::sink(type = "output", split = FALSE)
  [03:00:27.695]         if (TRUE) {
  [03:00:27.695]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:27.695]         }
  [03:00:27.695]         else {
  [03:00:27.695]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:27.695]         }
  [03:00:27.695]         base::close(...future.stdout)
  [03:00:27.695]         ...future.stdout <- NULL
  [03:00:27.695]     }
  [03:00:27.695]     ...future.result$conditions <- ...future.conditions
  [03:00:27.695]     ...future.result
  [03:00:27.695] }
  [03:00:27.702] requestCore(): workers = 2
  [03:00:27.708] MulticoreFuture started
  [03:00:27.725] plan(): Setting new future strategy stack:
  [03:00:27.739] Packages needed by the future expression (n = 0): <none>
  [03:00:27.741] Packages needed by future strategies (n = 0): <none>
  [03:00:27.726] List of future strategies:
  [03:00:27.726] 1. sequential:
  [03:00:27.726]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.726]    - tweaked: FALSE
  [03:00:27.726]    - call: NULL
  [03:00:27.750] plan(): nbrOfWorkers() = 1
  [03:00:27.772] plan(): Setting new future strategy stack:
  [03:00:27.773] List of future strategies:
  [03:00:27.773] 1. multicore:
  [03:00:27.773]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [03:00:27.773]    - tweaked: FALSE
  [03:00:27.773]    - call: plan(strategy)
  [03:00:27.777] plan(): nbrOfWorkers() = 2
  [03:00:27.783] {
  [03:00:27.783]     {
  [03:00:27.783]         ...future.startTime <- base::Sys.time()
  [03:00:27.783]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:27.783]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:27.783]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:27.783]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:27.783]             future.resolve.recursive = NULL, width = 80L)
  [03:00:27.783]         {
  [03:00:27.783]             {
  [03:00:27.783]                 {
  [03:00:27.783]                   base::local({
  [03:00:27.783]                     has_future <- base::requireNamespace("future", 
  [03:00:27.783]                       quietly = TRUE)
  [03:00:27.783]                     version <- if (has_future) 
  [03:00:27.783]                       utils::packageVersion("future")
  [03:00:27.783]                     else NULL
  [03:00:27.783]                     if (!has_future || version < "1.8.0") {
  [03:00:27.783]                       info <- base::c(r_version = base::gsub("R version ", 
  [03:00:27.783]                         "", base::R.version$version.string), 
  [03:00:27.783]                         platform = base::sprintf("%s (%s-bit)", 
  [03:00:27.783]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:27.783]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:27.783]                           "release", "version")], collapse = " "), 
  [03:00:27.783]                         hostname = base::Sys.info()[["nodename"]])
  [03:00:27.783]                       info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:27.783]                         info)
  [03:00:27.783]                       info <- base::paste(info, collapse = "; ")
  [03:00:27.783]                       if (!has_future) {
  [03:00:27.783]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:27.783]                           info)
  [03:00:27.783]                       }
  [03:00:27.783]                       else {
  [03:00:27.783]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:27.783]                           info, version)
  [03:00:27.783]                       }
  [03:00:27.783]                       base::stop(msg)
  [03:00:27.783]                     }
  [03:00:27.783]                   })
  [03:00:27.783]                 }
  [03:00:27.783]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [03:00:27.783]                 base::options(mc.cores = 1L)
  [03:00:27.783]             }
  [03:00:27.783]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:27.783]         }
  [03:00:27.783]     }
  [03:00:27.783]     if (base::is.na(TRUE)) {
  [03:00:27.783]     }
  [03:00:27.783]     else {
  [03:00:27.783]         if (TRUE) {
  [03:00:27.783]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:27.783]                 open = "w")
  [03:00:27.783]         }
  [03:00:27.783]         else {
  [03:00:27.783]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:27.783]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:27.783]         }
  [03:00:27.783]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:27.783]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:27.783]             base::sink(type = "output", split = FALSE)
  [03:00:27.783]             base::close(...future.stdout)
  [03:00:27.783]         }, add = TRUE)
  [03:00:27.783]     }
  [03:00:27.783]     ...future.frame <- base::sys.nframe()
  [03:00:27.783]     ...future.conditions <- base::list()
  [03:00:27.783]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:27.783]     ...future.result <- base::tryCatch({
  [03:00:27.783]         base::withCallingHandlers({
  [03:00:27.783]             ...future.value <- base::withVisible(base::local({
  [03:00:27.783]                 message(sprintf("Calculating tile #%d of %d ...", 
  [03:00:27.783]                   ii, n), appendLF = FALSE)
  [03:00:27.783]                 fit <- mandelbrot(C)
  [03:00:27.783]                 delay(fit)
  [03:00:27.783]                 message(" done")
  [03:00:27.783]                 fit
  [03:00:27.783]             }))
  [03:00:27.783]             future::FutureResult(value = ...future.value$value, 
  [03:00:27.783]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.783]                   ...future.rng), started = ...future.startTime, 
  [03:00:27.783]                 version = "1.8")
  [03:00:27.783]         }, condition = base::local({
  [03:00:27.783]             c <- base::c
  [03:00:27.783]             inherits <- base::inherits
  [03:00:27.783]             invokeRestart <- base::invokeRestart
  [03:00:27.783]             length <- base::length
  [03:00:27.783]             list <- base::list
  [03:00:27.783]             seq.int <- base::seq.int
  [03:00:27.783]             signalCondition <- base::signalCondition
  [03:00:27.783]             sys.calls <- base::sys.calls
  [03:00:27.783]             Sys.time <- base::Sys.time
  [03:00:27.783]             `[[` <- base::`[[`
  [03:00:27.783]             `+` <- base::`+`
  [03:00:27.783]             `<<-` <- base::`<<-`
  [03:00:27.783]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:27.783]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:27.783]                   3L)]
  [03:00:27.783]             }
  [03:00:27.783]             function(cond) {
  [03:00:27.783]                 if (inherits(cond, "error")) {
  [03:00:27.783]                   sessionInformation <- function() {
  [03:00:27.783]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:27.783]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:27.783]                       search = base::search(), system = base::Sys.info())
  [03:00:27.783]                   }
  [03:00:27.783]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.783]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:27.783]                     cond$call), session = sessionInformation(), 
  [03:00:27.783]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:27.783]                   signalCondition(cond)
  [03:00:27.783]                 }
  [03:00:27.783]                 else if (inherits(cond, "condition")) {
  [03:00:27.783]                   signal <- FALSE && inherits(cond, character(0))
  [03:00:27.783]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.783]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:27.783]                   if (!signal) {
  [03:00:27.783]                     muffleCondition <- function (cond) 
  [03:00:27.783]                     {
  [03:00:27.783]                       inherits <- base::inherits
  [03:00:27.783]                       invokeRestart <- base::invokeRestart
  [03:00:27.783]                       muffled <- FALSE
  [03:00:27.783]                       if (inherits(cond, "message")) {
  [03:00:27.783]                         invokeRestart("muffleMessage")
  [03:00:27.783]                         muffled <- TRUE
  [03:00:27.783]                       }
  [03:00:27.783]                       else if (inherits(cond, "warning")) {
  [03:00:27.783]                         invokeRestart("muffleWarning")
  [03:00:27.783]                         muffled <- TRUE
  [03:00:27.783]                       }
  [03:00:27.783]                       else if (inherits(cond, "condition")) {
  [03:00:27.783]                         computeRestarts <- base::computeRestarts
  [03:00:27.783]                         grepl <- base::grepl
  [03:00:27.783]                         is.null <- base::is.null
  [03:00:27.783]                         restarts <- computeRestarts(cond)
  [03:00:27.783]                         for (restart in restarts) {
  [03:00:27.783]                           name <- restart$name
  [03:00:27.783]                           if (is.null(name)) 
  [03:00:27.783]                             next
  [03:00:27.783]                           if (!grepl("^muffle", name)) 
  [03:00:27.783]                             next
  [03:00:27.783]                           invokeRestart(restart)
  [03:00:27.783]                           muffled <- TRUE
  [03:00:27.783]                           break
  [03:00:27.783]                         }
  [03:00:27.783]                       }
  [03:00:27.783]                       invisible(muffled)
  [03:00:27.783]                     }
  [03:00:27.783]                     muffleCondition(cond)
  [03:00:27.783]                   }
  [03:00:27.783]                 }
  [03:00:27.783]             }
  [03:00:27.783]         }))
  [03:00:27.783]     }, error = function(ex) {
  [03:00:27.783]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:27.783]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.783]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:27.783]     }, finally = {
  [03:00:27.783]         {
  [03:00:27.783]             {
  [03:00:27.783]                 base::options(mc.cores = ...future.mc.cores.old)
  [03:00:27.783]             }
  [03:00:27.783]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:27.783]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:27.783]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [03:00:27.783]                 earlySignal = FALSE, label = NULL, ...) 
  [03:00:27.783]             {
  [03:00:27.783]                 if (substitute) 
  [03:00:27.783]                   expr <- substitute(expr)
  [03:00:27.783]                 if (is.function(workers)) 
  [03:00:27.783]                   workers <- workers()
  [03:00:27.783]                 workers <- as.integer(workers)
  [03:00:27.783]                 stop_if_not(is.finite(workers), workers >= 1L)
  [03:00:27.783]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [03:00:27.783]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [03:00:27.783]                     lazy = lazy, seed = seed, globals = globals, 
  [03:00:27.783]                     local = TRUE, label = label, ...))
  [03:00:27.783]                 }
  [03:00:27.783]                 oopts <- options(mc.cores = workers)
  [03:00:27.783]                 on.exit(options(oopts))
  [03:00:27.783]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [03:00:27.783]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:27.783]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [03:00:27.783]                   label = label, ...)
  [03:00:27.783]                 if (!future$lazy) 
  [03:00:27.783]                   future <- run(future)
  [03:00:27.783]                 invisible(future)
  [03:00:27.783]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:27.783]         }
  [03:00:27.783]         base::options(...future.oldOptions)
  [03:00:27.783]     })
  [03:00:27.783]     Sys.time
  [03:00:27.783]     if (base::is.na(TRUE)) {
  [03:00:27.783]     }
  [03:00:27.783]     else {
  [03:00:27.783]         base::sink(type = "output", split = FALSE)
  [03:00:27.783]         if (TRUE) {
  [03:00:27.783]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:27.783]         }
  [03:00:27.783]         else {
  [03:00:27.783]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:27.783]         }
  [03:00:27.783]         base::close(...future.stdout)
  [03:00:27.783]         ...future.stdout <- NULL
  [03:00:27.783]     }
  [03:00:27.783]     ...future.result$conditions <- ...future.conditions
  [03:00:27.783]     ...future.result
  [03:00:27.783] }
  [03:00:27.790] requestCore(): workers = 2
  [03:00:27.810] MulticoreFuture started
  [03:00:27.817] plan(): Setting new future strategy stack:
  Plotting tile #1 of 4 ...
  [03:00:27.818] List of future strategies:
  [03:00:27.818] 1. sequential:
  [03:00:27.818]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.818]    - tweaked: FALSE
  [03:00:27.818]    - call: NULL
  [03:00:27.821] plan(): nbrOfWorkers() = 1
  [03:00:27.832] plan(): Setting new future strategy stack:
  [03:00:27.833] signalConditions() ...
  [03:00:27.833]  - include = 'immediateCondition'
  [03:00:27.832] List of future strategies:
  [03:00:27.832] 1. multicore:
  [03:00:27.832]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [03:00:27.832]    - tweaked: FALSE
  [03:00:27.832]    - call: plan(strategy)
  [03:00:27.834]  - exclude = 
  [03:00:27.834]  - resignal = FALSE
  [03:00:27.835]  - Number of conditions: 2
  [03:00:27.836] signalConditions() ... done
  [03:00:27.836] plan(): nbrOfWorkers() = 2
  [03:00:27.836] signalConditions() ...
  [03:00:27.837]  - include = 'immediateCondition'
  [03:00:27.837]  - exclude = 
  [03:00:27.838]  - resignal = FALSE
  [03:00:27.838]  - Number of conditions: 2
  [03:00:27.838] signalConditions() ... done
  [03:00:27.839] Future state: 'finished'
  [03:00:27.840] signalConditions() ...
  [03:00:27.840]  - include = 'condition'
  [03:00:27.841]  - exclude = 'immediateCondition'
  [03:00:27.841]  - resignal = TRUE
  [03:00:27.842]  - Number of conditions: 2
  [03:00:27.842]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #1 of 4 ...[03:00:27.843]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [03:00:27.844] signalConditions() ... done
  Plotting tile #2 of 4 ...
  [03:00:27.850] signalConditions() ...
  [03:00:27.851]  - include = 'immediateCondition'
  [03:00:27.851]  - exclude = 
  [03:00:27.852]  - resignal = FALSE
  [03:00:27.852]  - Number of conditions: 2
  [03:00:27.853] signalConditions() ... done
  [03:00:27.853] signalConditions() ...
  [03:00:27.854]  - include = 'immediateCondition'
  [03:00:27.854]  - exclude = 
  [03:00:27.855]  - resignal = FALSE
  [03:00:27.855]  - Number of conditions: 2
  [03:00:27.856] signalConditions() ... done
  [03:00:27.856] Future state: 'finished'
  [03:00:27.857] signalConditions() ...
  [03:00:27.857]  - include = 'condition'
  [03:00:27.858]  - exclude = 'immediateCondition'
  [03:00:27.858]  - resignal = TRUE
  [03:00:27.859]  - Number of conditions: 2
  [03:00:27.859]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #2 of 4 ...[03:00:27.860]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [03:00:27.860] signalConditions() ... done
  [03:00:27.866] Packages needed by the future expression (n = 0): <none>
  [03:00:27.867] Packages needed by future strategies (n = 0): <none>
  [03:00:27.875] {
  [03:00:27.875]     {
  [03:00:27.875]         ...future.startTime <- base::Sys.time()
  [03:00:27.875]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:27.875]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:27.875]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:27.875]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:27.875]             future.resolve.recursive = NULL, width = 80L)
  [03:00:27.875]         {
  [03:00:27.875]             {
  [03:00:27.875]                 {
  [03:00:27.875]                   base::local({
  [03:00:27.875]                     has_future <- base::requireNamespace("future", 
  [03:00:27.875]                       quietly = TRUE)
  [03:00:27.875]                     version <- if (has_future) 
  [03:00:27.875]                       utils::packageVersion("future")
  [03:00:27.875]                     else NULL
  [03:00:27.875]                     if (!has_future || version < "1.8.0") {
  [03:00:27.875]                       info <- base::c(r_version = base::gsub("R version ", 
  [03:00:27.875]                         "", base::R.version$version.string), 
  [03:00:27.875]                         platform = base::sprintf("%s (%s-bit)", 
  [03:00:27.875]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:27.875]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:27.875]                           "release", "version")], collapse = " "), 
  [03:00:27.875]                         hostname = base::Sys.info()[["nodename"]])
  [03:00:27.875]                       info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:27.875]                         info)
  [03:00:27.875]                       info <- base::paste(info, collapse = "; ")
  [03:00:27.875]                       if (!has_future) {
  [03:00:27.875]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:27.875]                           info)
  [03:00:27.875]                       }
  [03:00:27.875]                       else {
  [03:00:27.875]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:27.875]                           info, version)
  [03:00:27.875]                       }
  [03:00:27.875]                       base::stop(msg)
  [03:00:27.875]                     }
  [03:00:27.875]                   })
  [03:00:27.875]                 }
  [03:00:27.875]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [03:00:27.875]                 base::options(mc.cores = 1L)
  [03:00:27.875]             }
  [03:00:27.875]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:27.875]         }
  [03:00:27.875]     }
  [03:00:27.875]     if (base::is.na(TRUE)) {
  [03:00:27.875]     }
  [03:00:27.875]     else {
  [03:00:27.875]         if (TRUE) {
  [03:00:27.875]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:27.875]                 open = "w")
  [03:00:27.875]         }
  [03:00:27.875]         else {
  [03:00:27.875]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:27.875]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:27.875]         }
  [03:00:27.875]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:27.875]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:27.875]             base::sink(type = "output", split = FALSE)
  [03:00:27.875]             base::close(...future.stdout)
  [03:00:27.875]         }, add = TRUE)
  [03:00:27.875]     }
  [03:00:27.875]     ...future.frame <- base::sys.nframe()
  [03:00:27.875]     ...future.conditions <- base::list()
  [03:00:27.875]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:27.875]     ...future.result <- base::tryCatch({
  [03:00:27.875]         base::withCallingHandlers({
  [03:00:27.875]             ...future.value <- base::withVisible(base::local({
  [03:00:27.875]                 message(sprintf("Calculating tile #%d of %d ...", 
  [03:00:27.875]                   ii, n), appendLF = FALSE)
  [03:00:27.875]                 fit <- mandelbrot(C)
  [03:00:27.875]                 delay(fit)
  [03:00:27.875]                 message(" done")
  [03:00:27.875]                 fit
  [03:00:27.875]             }))
  [03:00:27.875]             future::FutureResult(value = ...future.value$value, 
  [03:00:27.875]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.875]                   ...future.rng), started = ...future.startTime, 
  [03:00:27.875]                 version = "1.8")
  [03:00:27.875]         }, condition = base::local({
  [03:00:27.875]             c <- base::c
  [03:00:27.875]             inherits <- base::inherits
  [03:00:27.875]             invokeRestart <- base::invokeRestart
  [03:00:27.875]             length <- base::length
  [03:00:27.875]             list <- base::list
  [03:00:27.875]             seq.int <- base::seq.int
  [03:00:27.875]             signalCondition <- base::signalCondition
  [03:00:27.875]             sys.calls <- base::sys.calls
  [03:00:27.875]             Sys.time <- base::Sys.time
  [03:00:27.875]             `[[` <- base::`[[`
  [03:00:27.875]             `+` <- base::`+`
  [03:00:27.875]             `<<-` <- base::`<<-`
  [03:00:27.875]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:27.875]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:27.875]                   3L)]
  [03:00:27.875]             }
  [03:00:27.875]             function(cond) {
  [03:00:27.875]                 if (inherits(cond, "error")) {
  [03:00:27.875]                   sessionInformation <- function() {
  [03:00:27.875]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:27.875]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:27.875]                       search = base::search(), system = base::Sys.info())
  [03:00:27.875]                   }
  [03:00:27.875]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.875]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:27.875]                     cond$call), session = sessionInformation(), 
  [03:00:27.875]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:27.875]                   signalCondition(cond)
  [03:00:27.875]                 }
  [03:00:27.875]                 else if (inherits(cond, "condition")) {
  [03:00:27.875]                   signal <- FALSE && inherits(cond, character(0))
  [03:00:27.875]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.875]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:27.875]                   if (!signal) {
  [03:00:27.875]                     muffleCondition <- function (cond) 
  [03:00:27.875]                     {
  [03:00:27.875]                       inherits <- base::inherits
  [03:00:27.875]                       invokeRestart <- base::invokeRestart
  [03:00:27.875]                       muffled <- FALSE
  [03:00:27.875]                       if (inherits(cond, "message")) {
  [03:00:27.875]                         invokeRestart("muffleMessage")
  [03:00:27.875]                         muffled <- TRUE
  [03:00:27.875]                       }
  [03:00:27.875]                       else if (inherits(cond, "warning")) {
  [03:00:27.875]                         invokeRestart("muffleWarning")
  [03:00:27.875]                         muffled <- TRUE
  [03:00:27.875]                       }
  [03:00:27.875]                       else if (inherits(cond, "condition")) {
  [03:00:27.875]                         computeRestarts <- base::computeRestarts
  [03:00:27.875]                         grepl <- base::grepl
  [03:00:27.875]                         is.null <- base::is.null
  [03:00:27.875]                         restarts <- computeRestarts(cond)
  [03:00:27.875]                         for (restart in restarts) {
  [03:00:27.875]                           name <- restart$name
  [03:00:27.875]                           if (is.null(name)) 
  [03:00:27.875]                             next
  [03:00:27.875]                           if (!grepl("^muffle", name)) 
  [03:00:27.875]                             next
  [03:00:27.875]                           invokeRestart(restart)
  [03:00:27.875]                           muffled <- TRUE
  [03:00:27.875]                           break
  [03:00:27.875]                         }
  [03:00:27.875]                       }
  [03:00:27.875]                       invisible(muffled)
  [03:00:27.875]                     }
  [03:00:27.875]                     muffleCondition(cond)
  [03:00:27.875]                   }
  [03:00:27.875]                 }
  [03:00:27.875]             }
  [03:00:27.875]         }))
  [03:00:27.875]     }, error = function(ex) {
  [03:00:27.875]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:27.875]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.875]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:27.875]     }, finally = {
  [03:00:27.875]         {
  [03:00:27.875]             {
  [03:00:27.875]                 base::options(mc.cores = ...future.mc.cores.old)
  [03:00:27.875]             }
  [03:00:27.875]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:27.875]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:27.875]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [03:00:27.875]                 earlySignal = FALSE, label = NULL, ...) 
  [03:00:27.875]             {
  [03:00:27.875]                 if (substitute) 
  [03:00:27.875]                   expr <- substitute(expr)
  [03:00:27.875]                 if (is.function(workers)) 
  [03:00:27.875]                   workers <- workers()
  [03:00:27.875]                 workers <- as.integer(workers)
  [03:00:27.875]                 stop_if_not(is.finite(workers), workers >= 1L)
  [03:00:27.875]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [03:00:27.875]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [03:00:27.875]                     lazy = lazy, seed = seed, globals = globals, 
  [03:00:27.875]                     local = TRUE, label = label, ...))
  [03:00:27.875]                 }
  [03:00:27.875]                 oopts <- options(mc.cores = workers)
  [03:00:27.875]                 on.exit(options(oopts))
  [03:00:27.875]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [03:00:27.875]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:27.875]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [03:00:27.875]                   label = label, ...)
  [03:00:27.875]                 if (!future$lazy) 
  [03:00:27.875]                   future <- run(future)
  [03:00:27.875]                 invisible(future)
  [03:00:27.875]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:27.875]         }
  [03:00:27.875]         base::options(...future.oldOptions)
  [03:00:27.875]     })
  [03:00:27.875]     Sys.time
  [03:00:27.875]     if (base::is.na(TRUE)) {
  [03:00:27.875]     }
  [03:00:27.875]     else {
  [03:00:27.875]         base::sink(type = "output", split = FALSE)
  [03:00:27.875]         if (TRUE) {
  [03:00:27.875]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:27.875]         }
  [03:00:27.875]         else {
  [03:00:27.875]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:27.875]         }
  [03:00:27.875]         base::close(...future.stdout)
  [03:00:27.875]         ...future.stdout <- NULL
  [03:00:27.875]     }
  [03:00:27.875]     ...future.result$conditions <- ...future.conditions
  [03:00:27.875]     ...future.result
  [03:00:27.875] }
  [03:00:27.882] requestCore(): workers = 2
  [03:00:27.887] MulticoreFuture started
  [03:00:27.894] Packages needed by the future expression (n = 0): <none>
  [03:00:27.895] Packages needed by future strategies (n = 0): <none>
  [03:00:27.906] plan(): Setting new future strategy stack:
  [03:00:27.907] List of future strategies:
  [03:00:27.907] 1. sequential:
  [03:00:27.907]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.907]    - tweaked: FALSE
  [03:00:27.907]    - call: NULL
  [03:00:27.909] plan(): nbrOfWorkers() = 1
  [03:00:27.930] plan(): Setting new future strategy stack:
  [03:00:27.925] {
  [03:00:27.925]     {
  [03:00:27.925]         ...future.startTime <- base::Sys.time()
  [03:00:27.925]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:00:27.925]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:00:27.925]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:00:27.925]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:00:27.925]             future.resolve.recursive = NULL, width = 80L)
  [03:00:27.925]         {
  [03:00:27.925]             {
  [03:00:27.925]                 {
  [03:00:27.925]                   base::local({
  [03:00:27.925]                     has_future <- base::requireNamespace("future", 
  [03:00:27.925]                       quietly = TRUE)
  [03:00:27.925]                     version <- if (has_future) 
  [03:00:27.925]                       utils::packageVersion("future")
  [03:00:27.925]                     else NULL
  [03:00:27.925]                     if (!has_future || version < "1.8.0") {
  [03:00:27.925]                       info <- base::c(r_version = base::gsub("R version ", 
  [03:00:27.925]                         "", base::R.version$version.string), 
  [03:00:27.925]                         platform = base::sprintf("%s (%s-bit)", 
  [03:00:27.925]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:00:27.925]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:00:27.925]                           "release", "version")], collapse = " "), 
  [03:00:27.925]                         hostname = base::Sys.info()[["nodename"]])
  [03:00:27.925]                       info <- base::sprintf("%s: %s", base::names(info), 
  [03:00:27.925]                         info)
  [03:00:27.925]                       info <- base::paste(info, collapse = "; ")
  [03:00:27.925]                       if (!has_future) {
  [03:00:27.925]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:00:27.925]                           info)
  [03:00:27.925]                       }
  [03:00:27.925]                       else {
  [03:00:27.925]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:00:27.925]                           info, version)
  [03:00:27.925]                       }
  [03:00:27.925]                       base::stop(msg)
  [03:00:27.925]                     }
  [03:00:27.925]                   })
  [03:00:27.925]                 }
  [03:00:27.925]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [03:00:27.925]                 base::options(mc.cores = 1L)
  [03:00:27.925]             }
  [03:00:27.925]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:00:27.925]         }
  [03:00:27.925]     }
  [03:00:27.925]     if (base::is.na(TRUE)) {
  [03:00:27.925]     }
  [03:00:27.925]     else {
  [03:00:27.925]         if (TRUE) {
  [03:00:27.925]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:00:27.925]                 open = "w")
  [03:00:27.925]         }
  [03:00:27.925]         else {
  [03:00:27.925]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:00:27.925]                 windows = "NUL", "/dev/null"), open = "w")
  [03:00:27.925]         }
  [03:00:27.925]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:00:27.925]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:00:27.925]             base::sink(type = "output", split = FALSE)
  [03:00:27.925]             base::close(...future.stdout)
  [03:00:27.925]         }, add = TRUE)
  [03:00:27.925]     }
  [03:00:27.925]     ...future.frame <- base::sys.nframe()
  [03:00:27.925]     ...future.conditions <- base::list()
  [03:00:27.925]     ...future.rng <- base::globalenv()$.Random.seed
  [03:00:27.925]     ...future.result <- base::tryCatch({
  [03:00:27.925]         base::withCallingHandlers({
  [03:00:27.925]             ...future.value <- base::withVisible(base::local({
  [03:00:27.925]                 message(sprintf("Calculating tile #%d of %d ...", 
  [03:00:27.925]                   ii, n), appendLF = FALSE)
  [03:00:27.925]                 fit <- mandelbrot(C)
  [03:00:27.925]                 delay(fit)
  [03:00:27.925]                 message(" done")
  [03:00:27.925]                 fit
  [03:00:27.925]             }))
  [03:00:27.925]             future::FutureResult(value = ...future.value$value, 
  [03:00:27.925]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.925]                   ...future.rng), started = ...future.startTime, 
  [03:00:27.925]                 version = "1.8")
  [03:00:27.925]         }, condition = base::local({
  [03:00:27.925]             c <- base::c
  [03:00:27.925]             inherits <- base::inherits
  [03:00:27.925]             invokeRestart <- base::invokeRestart
  [03:00:27.925]             length <- base::length
  [03:00:27.925]             list <- base::list
  [03:00:27.925]             seq.int <- base::seq.int
  [03:00:27.925]             signalCondition <- base::signalCondition
  [03:00:27.925]             sys.calls <- base::sys.calls
  [03:00:27.925]             Sys.time <- base::Sys.time
  [03:00:27.925]             `[[` <- base::`[[`
  [03:00:27.925]             `+` <- base::`+`
  [03:00:27.925]             `<<-` <- base::`<<-`
  [03:00:27.925]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:00:27.925]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:00:27.925]                   3L)]
  [03:00:27.925]             }
  [03:00:27.925]             function(cond) {
  [03:00:27.925]                 if (inherits(cond, "error")) {
  [03:00:27.925]                   sessionInformation <- function() {
  [03:00:27.925]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:00:27.925]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:00:27.925]                       search = base::search(), system = base::Sys.info())
  [03:00:27.925]                   }
  [03:00:27.925]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.925]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:00:27.925]                     cond$call), session = sessionInformation(), 
  [03:00:27.925]                     timestamp = Sys.time(), signaled = 0L)
  [03:00:27.925]                   signalCondition(cond)
  [03:00:27.925]                 }
  [03:00:27.925]                 else if (inherits(cond, "condition")) {
  [03:00:27.925]                   signal <- FALSE && inherits(cond, character(0))
  [03:00:27.925]                   ...future.conditions[[length(...future.conditions) + 
  [03:00:27.925]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:00:27.925]                   if (!signal) {
  [03:00:27.925]                     muffleCondition <- function (cond) 
  [03:00:27.925]                     {
  [03:00:27.925]                       inherits <- base::inherits
  [03:00:27.925]                       invokeRestart <- base::invokeRestart
  [03:00:27.925]                       muffled <- FALSE
  [03:00:27.925]                       if (inherits(cond, "message")) {
  [03:00:27.925]                         invokeRestart("muffleMessage")
  [03:00:27.925]                         muffled <- TRUE
  [03:00:27.925]                       }
  [03:00:27.925]                       else if (inherits(cond, "warning")) {
  [03:00:27.925]                         invokeRestart("muffleWarning")
  [03:00:27.925]                         muffled <- TRUE
  [03:00:27.925]                       }
  [03:00:27.925]                       else if (inherits(cond, "condition")) {
  [03:00:27.925]                         computeRestarts <- base::computeRestarts
  [03:00:27.925]                         grepl <- base::grepl
  [03:00:27.925]                         is.null <- base::is.null
  [03:00:27.925]                         restarts <- computeRestarts(cond)
  [03:00:27.925]                         for (restart in restarts) {
  [03:00:27.925]                           name <- restart$name
  [03:00:27.925]                           if (is.null(name)) 
  [03:00:27.925]                             next
  [03:00:27.925]                           if (!grepl("^muffle", name)) 
  [03:00:27.925]                             next
  [03:00:27.925]                           invokeRestart(restart)
  [03:00:27.925]                           muffled <- TRUE
  [03:00:27.925]                           break
  [03:00:27.925]                         }
  [03:00:27.925]                       }
  [03:00:27.925]                       invisible(muffled)
  [03:00:27.925]                     }
  [03:00:27.925]                     muffleCondition(cond)
  [03:00:27.925]                   }
  [03:00:27.925]                 }
  [03:00:27.925]             }
  [03:00:27.925]         }))
  [03:00:27.925]     }, error = function(ex) {
  [03:00:27.925]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:00:27.925]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:00:27.925]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:00:27.925]     }, finally = {
  [03:00:27.925]         {
  [03:00:27.925]             {
  [03:00:27.925]                 base::options(mc.cores = ...future.mc.cores.old)
  [03:00:27.925]             }
  [03:00:27.925]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:00:27.925]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:00:27.925]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [03:00:27.925]                 earlySignal = FALSE, label = NULL, ...) 
  [03:00:27.925]             {
  [03:00:27.925]                 if (substitute) 
  [03:00:27.925]                   expr <- substitute(expr)
  [03:00:27.925]                 if (is.function(workers)) 
  [03:00:27.925]                   workers <- workers()
  [03:00:27.925]                 workers <- as.integer(workers)
  [03:00:27.925]                 stop_if_not(is.finite(workers), workers >= 1L)
  [03:00:27.925]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [03:00:27.925]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [03:00:27.925]                     lazy = lazy, seed = seed, globals = globals, 
  [03:00:27.925]                     local = TRUE, label = label, ...))
  [03:00:27.925]                 }
  [03:00:27.925]                 oopts <- options(mc.cores = workers)
  [03:00:27.925]                 on.exit(options(oopts))
  [03:00:27.925]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [03:00:27.925]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:00:27.925]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [03:00:27.925]                   label = label, ...)
  [03:00:27.925]                 if (!future$lazy) 
  [03:00:27.925]                   future <- run(future)
  [03:00:27.925]                 invisible(future)
  [03:00:27.925]             }), .cleanup = FALSE, .init = FALSE)
  [03:00:27.925]         }
  [03:00:27.925]         base::options(...future.oldOptions)
  [03:00:27.925]     })
  [03:00:27.925]     Sys.time
  [03:00:27.925]     if (base::is.na(TRUE)) {
  [03:00:27.925]     }
  [03:00:27.925]     else {
  [03:00:27.925]         base::sink(type = "output", split = FALSE)
  [03:00:27.925]         if (TRUE) {
  [03:00:27.925]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:00:27.925]         }
  [03:00:27.925]         else {
  [03:00:27.925]             ...future.result["stdout"] <- base::list(NULL)
  [03:00:27.925]         }
  [03:00:27.925]         base::close(...future.stdout)
  [03:00:27.925]         ...future.stdout <- NULL
  [03:00:27.925]     }
  [03:00:27.925]     ...future.result$conditions <- ...future.conditions
  [03:00:27.925]     ...future.result
  [03:00:27.925] }
  [03:00:27.933] requestCore(): workers = 2
  [03:00:27.939] MulticoreFuture started
  [03:00:27.930] List of future strategies:
  [03:00:27.930] 1. multicore:
  [03:00:27.930]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [03:00:27.930]    - tweaked: FALSE
  [03:00:27.930]    - call: plan(strategy)
  [03:00:27.956] plan(): nbrOfWorkers() = 2
  Plotting tile #3 of 4 ...
  [03:00:27.965] plan(): Setting new future strategy stack:
  [03:00:27.966] List of future strategies:
  [03:00:27.966] 1. sequential:
  [03:00:27.966]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:00:27.966]    - tweaked: FALSE
  [03:00:27.966]    - call: NULL
  [03:00:27.971] plan(): nbrOfWorkers() = 1
  [03:00:27.975] signalConditions() ...
  [03:00:27.976]  - include = 'immediateCondition'
  [03:00:27.977]  - exclude = 
  [03:00:27.977]  - resignal = FALSE
  [03:00:27.978]  - Number of conditions: 2
  [03:00:27.979] signalConditions() ... done
  [03:00:27.980] signalConditions() ...
  [03:00:27.981]  - include = 'immediateCondition'
  [03:00:27.982]  - exclude = 
  [03:00:27.982]  - resignal = FALSE
  [03:00:27.983]  - Number of conditions: 2
  [03:00:27.983] signalConditions() ... done
  [03:00:27.984] Future state: 'finished'
  [03:00:27.985] signalConditions() ...
  [03:00:27.986]  - include = 'condition'
  [03:00:27.987]  - exclude = 'immediateCondition'
  [03:00:27.988]  - resignal = TRUE
  [03:00:27.989]  - Number of conditions: 2
  [03:00:27.990]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #3 of 4 ...[03:00:27.990] plan(): Setting new future strategy stack:
  [03:00:27.991]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [03:00:27.992] signalConditions() ... done
  [03:00:27.991] List of future strategies:
  [03:00:27.991] 1. multicore:
  [03:00:27.991]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [03:00:27.991]    - tweaked: FALSE
  [03:00:27.991]    - call: plan(strategy)
  [03:00:27.995] plan(): nbrOfWorkers() = 2
  Plotting tile #4 of 4 ...
  [03:00:28.006] signalConditions() ...
  [03:00:28.006]  - include = 'immediateCondition'
  [03:00:28.007]  - exclude = 
  [03:00:28.007]  - resignal = FALSE
  [03:00:28.008]  - Number of conditions: 2
  [03:00:28.009] signalConditions() ... done
  [03:00:28.009] signalConditions() ...
  [03:00:28.010]  - include = 'immediateCondition'
  [03:00:28.010]  - exclude = 
  [03:00:28.011]  - resignal = FALSE
  [03:00:28.011]  - Number of conditions: 2
  [03:00:28.012] signalConditions() ... done
  [03:00:28.012] Future state: 'finished'
  [03:00:28.013] signalConditions() ...
  [03:00:28.013]  - include = 'condition'
  [03:00:28.014]  - exclude = 'immediateCondition'
  [03:00:28.014]  - resignal = TRUE
  [03:00:28.015]  - Number of conditions: 2
  [03:00:28.015]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #4 of 4 ...[03:00:28.016]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [03:00:28.016] signalConditions() ... done
  
  > close.screen()
  [1] 1 2 3 4 5 6 7 8
  
  > message("SUGGESTION: Try to rerun this demo after changing strategy for how futures are resolved, e.g. plan(multiprocess).\n")
  SUGGESTION: Try to rerun this demo after changing strategy for how futures are resolved, e.g. plan(multiprocess).
  
  - plan('multicore') ... DONE
  - plan('multisession') ...
  [03:00:28.022] plan(): Setting new future strategy stack:
  [03:00:28.022] List of future strategies:
  [03:00:28.022] 1. multisession:
  [03:00:28.022]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [03:00:28.022]    - tweaked: FALSE
  [03:00:28.022]    - call: plan(strategy)
  [03:00:28.024] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [03:00:28.024] multisession:
  [03:00:28.024] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [03:00:28.024] - tweaked: FALSE
  [03:00:28.024] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 24310
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/data/gannet/ripley/R/R-devel/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/RtmpoaORtQ/future.parent=50646.c5d668bd889f.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpxHETCY/working_dir/RtmpoaORtQ/future.parent=50646.c5d668bd889f.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/demo.R:gannet.stats.ox.ac.uk:ripley:50646' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/RtmpoaORtQ/future.parent=50646.c5d668bd889f.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=24310 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  Error in get(name, envir = asNamespace(pkg), inherits = FALSE) : 
    object '.slaveRSOCK' not found
  Calls: ::: -> get
  Execution halted
  Killing worker process (PID 53627) if still alive
  [03:02:29.225] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(50646, signal = 0L)
  [1] TRUE
  Call: tools::pskill(50646, signal = 0L)
  [1] TRUE
  [03:02:29.227] - success
  [03:02:29.227] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 53627) was successfully killed: TRUE
  Error in makeRestartList(...) : 
    Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gannet.stats.ox.ac.uk'.
   * The error produced by socketConnection() was: 'reached elapsed time limit' (which suggests that the connection timeout of 120 seconds (argument 'connectTimeout') kicked in)
   * The localhost socket connection that failed to connect to the R worker used port 24310 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/demo.R:gannet.stats.ox.ac.uk:ripley:50646' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/RtmpoaORtQ/future.parent=50646.c5d668bd889f.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=24310 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 53627) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted
Running the tests in ‘tests/dotdotdot.R’ failed.
Complete output:
  > source("incl/start.R")
  [03:02:30.191] plan(): Setting new future strategy stack:
  [03:02:30.193] List of future strategies:
  [03:02:30.193] 1. sequential:
  [03:02:30.193]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:02:30.193]    - tweaked: FALSE
  [03:02:30.193]    - call: future::plan("sequential")
  [03:02:30.196] plan(): nbrOfWorkers() = 1
  > library("listenv")
  > 
  > for (cores in 1:availCores) {
  +   ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
  +   if (!fullTest && isWin32) next
  +   
  +   message(sprintf("Testing with %d cores ...", cores))
  +   options(mc.cores = cores)
  + 
  +   message("*** Global argument '...' ...")
  + 
  +   sum_fcns <- list()
  + 
  +   sum_fcns$A <- function(x, ...) {
  +     message("Arguments '...' exists: ", exists("...", inherits = TRUE))
  +     y %<-% { sum(x, ...) }
  +     y
  +   }
  + 
  + 
  +   sum_fcns$B <- function(x, ...) {
  +     sumt <- function(x) {
  +       message("Arguments '...' exists: ", exists("...", inherits = TRUE))
  +       y %<-% { sum(x, ...) }
  +       y
  +     }
  +     sumt(x)
  +   }
  + 
  +   sum_fcns$C <- function(x, y) {
  +     message("Arguments '...' exists: ", exists("...", inherits = TRUE))
  +     y %<-% { sum(x, y) }
  +     y
  +   }
  + 
  +   sum_fcns$D <- function(x, y) {
  +     message("Arguments '...' exists: ", exists("...", inherits = TRUE))
  +     y %<-% { sum(x, y, ...) }
  +     y
  +   }
  + 
  + 
  +   for (strategy in supportedStrategies(cores)) {
  +     message(sprintf("- plan('%s') ...", strategy))
  +     plan(strategy, substitute = FALSE)
  + 
  +     for (name in names(sum_fcns)) {
  +       message(sprintf("** Sum function '%s' with plan('%s') ...", name, strategy))
  +       sum_fcn <- sum_fcns[[name]]
  +       print(sum_fcn)
  +       y <- try(sum_fcn(1:2, 3))
  +       print(y)
  +       if (name %in% c("D")) {
  +         stopifnot(inherits(y, "try-error"))
  +       } else {
  +         stopifnot(y == 6)
  +       }
  +     }
  +   }
  + 
  +   message(sprintf("Testing with %d cores ... DONE", cores))
  + } ## for (cores ...)
  Testing with 1 cores ...
  *** Global argument '...' ...
  - plan('sequential') ...
  [03:02:30.490] plan(): Setting new future strategy stack:
  [03:02:30.491] List of future strategies:
  [03:02:30.491] 1. sequential:
  [03:02:30.491]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:02:30.491]    - tweaked: FALSE
  [03:02:30.491]    - call: plan(strategy, substitute = FALSE)
  [03:02:30.569] plan(): nbrOfWorkers() = 1
  ** Sum function 'A' with plan('sequential') ...
  function (x, ...) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, ...)
      }
      y
  }
  <bytecode: 0x33097b8>
  Arguments '...' exists: TRUE
  [03:02:30.576] getGlobalsAndPackages() ...
  [03:02:30.577] Searching for globals...
  [03:02:30.604] - globals found: [4] '{', 'sum', 'x', '...'
  [03:02:30.617] Searching for globals ... DONE
  [03:02:30.618] Resolving globals: FALSE
  [03:02:30.618] Tweak future expression to call with '...' arguments ...
  [03:02:30.619] Tweak future expression to call with '...' arguments ... DONE
  [03:02:30.623] The total size of the 2 globals is 112 bytes (112 bytes)
  [03:02:30.624] - globals: [2] 'x', 'future.call.arguments'
  [03:02:30.624] 
  [03:02:30.625] getGlobalsAndPackages() ... DONE
  [03:02:30.643] Packages needed by the future expression (n = 0): <none>
  [03:02:30.644] Packages needed by future strategies (n = 0): <none>
  [03:02:30.657] {
  [03:02:30.657]     {
  [03:02:30.657]         ...future.startTime <- base::Sys.time()
  [03:02:30.657]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:02:30.657]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:02:30.657]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [03:02:30.657]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:02:30.657]             future.resolve.recursive = NULL, width = 80L)
  [03:02:30.657]         {
  [03:02:30.657]             {
  [03:02:30.657]                 base::local({
  [03:02:30.657]                   has_future <- base::requireNamespace("future", 
  [03:02:30.657]                     quietly = TRUE)
  [03:02:30.657]                   version <- if (has_future) 
  [03:02:30.657]                     utils::packageVersion("future")
  [03:02:30.657]                   else NULL
  [03:02:30.657]                   if (!has_future || version < "1.8.0") {
  [03:02:30.657]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:02:30.657]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:02:30.657]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:02:30.657]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:02:30.657]                         "release", "version")], collapse = " "), 
  [03:02:30.657]                       hostname = base::Sys.info()[["nodename"]])
  [03:02:30.657]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:02:30.657]                       info)
  [03:02:30.657]                     info <- base::paste(info, collapse = "; ")
  [03:02:30.657]                     if (!has_future) {
  [03:02:30.657]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:02:30.657]                         info)
  [03:02:30.657]                     }
  [03:02:30.657]                     else {
  [03:02:30.657]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:02:30.657]                         info, version)
  [03:02:30.657]                     }
  [03:02:30.657]                     base::stop(msg)
  [03:02:30.657]                   }
  [03:02:30.657]                 })
  [03:02:30.657]             }
  [03:02:30.657]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:02:30.657]         }
  [03:02:30.657]     }
  [03:02:30.657]     if (base::is.na(TRUE)) {
  [03:02:30.657]     }
  [03:02:30.657]     else {
  [03:02:30.657]         if (TRUE) {
  [03:02:30.657]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:02:30.657]                 open = "w")
  [03:02:30.657]         }
  [03:02:30.657]         else {
  [03:02:30.657]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:02:30.657]                 windows = "NUL", "/dev/null"), open = "w")
  [03:02:30.657]         }
  [03:02:30.657]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:02:30.657]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:02:30.657]             base::sink(type = "output", split = FALSE)
  [03:02:30.657]             base::close(...future.stdout)
  [03:02:30.657]         }, add = TRUE)
  [03:02:30.657]     }
  [03:02:30.657]     ...future.frame <- base::sys.nframe()
  [03:02:30.657]     ...future.conditions <- base::list()
  [03:02:30.657]     ...future.rng <- base::globalenv()$.Random.seed
  [03:02:30.657]     ...future.result <- base::tryCatch({
  [03:02:30.657]         base::withCallingHandlers({
  [03:02:30.657]             ...future.value <- base::withVisible(base::local({
  [03:02:30.657]                 sum(x, ...)
  [03:02:30.657]             }))
  [03:02:30.657]             future::FutureResult(value = ...future.value$value, 
  [03:02:30.657]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:02:30.657]                   ...future.rng), started = ...future.startTime, 
  [03:02:30.657]                 version = "1.8")
  [03:02:30.657]         }, condition = base::local({
  [03:02:30.657]             c <- base::c
  [03:02:30.657]             inherits <- base::inherits
  [03:02:30.657]             invokeRestart <- base::invokeRestart
  [03:02:30.657]             length <- base::length
  [03:02:30.657]             list <- base::list
  [03:02:30.657]             seq.int <- base::seq.int
  [03:02:30.657]             signalCondition <- base::signalCondition
  [03:02:30.657]             sys.calls <- base::sys.calls
  [03:02:30.657]             Sys.time <- base::Sys.time
  [03:02:30.657]             `[[` <- base::`[[`
  [03:02:30.657]             `+` <- base::`+`
  [03:02:30.657]             `<<-` <- base::`<<-`
  [03:02:30.657]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:02:30.657]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:02:30.657]                   3L)]
  [03:02:30.657]             }
  [03:02:30.657]             function(cond) {
  [03:02:30.657]                 if (inherits(cond, "error")) {
  [03:02:30.657]                   sessionInformation <- function() {
  [03:02:30.657]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:02:30.657]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:02:30.657]                       search = base::search(), system = base::Sys.info())
  [03:02:30.657]                   }
  [03:02:30.657]                   ...future.conditions[[length(...future.conditions) + 
  [03:02:30.657]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:02:30.657]                     cond$call), session = sessionInformation(), 
  [03:02:30.657]                     timestamp = Sys.time(), signaled = 0L)
  [03:02:30.657]                   signalCondition(cond)
  [03:02:30.657]                 }
  [03:02:30.657]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:02:30.657]                 ))) {
  [03:02:30.657]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:02:30.657]                   ...future.conditions[[length(...future.conditions) + 
  [03:02:30.657]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:02:30.657]                   if (!signal) {
  [03:02:30.657]                     muffleCondition <- function (cond) 
  [03:02:30.657]                     {
  [03:02:30.657]                       inherits <- base::inherits
  [03:02:30.657]                       invokeRestart <- base::invokeRestart
  [03:02:30.657]                       muffled <- FALSE
  [03:02:30.657]                       if (inherits(cond, "message")) {
  [03:02:30.657]                         invokeRestart("muffleMessage")
  [03:02:30.657]                         muffled <- TRUE
  [03:02:30.657]                       }
  [03:02:30.657]                       else if (inherits(cond, "warning")) {
  [03:02:30.657]                         invokeRestart("muffleWarning")
  [03:02:30.657]                         muffled <- TRUE
  [03:02:30.657]                       }
  [03:02:30.657]                       else if (inherits(cond, "condition")) {
  [03:02:30.657]                         computeRestarts <- base::computeRestarts
  [03:02:30.657]                         grepl <- base::grepl
  [03:02:30.657]                         is.null <- base::is.null
  [03:02:30.657]                         restarts <- computeRestarts(cond)
  [03:02:30.657]                         for (restart in restarts) {
  [03:02:30.657]                           name <- restart$name
  [03:02:30.657]                           if (is.null(name)) 
  [03:02:30.657]                             next
  [03:02:30.657]                           if (!grepl("^muffle", name)) 
  [03:02:30.657]                             next
  [03:02:30.657]                           invokeRestart(restart)
  [03:02:30.657]                           muffled <- TRUE
  [03:02:30.657]                           break
  [03:02:30.657]                         }
  [03:02:30.657]                       }
  [03:02:30.657]                       invisible(muffled)
  [03:02:30.657]                     }
  [03:02:30.657]                     muffleCondition(cond)
  [03:02:30.657]                   }
  [03:02:30.657]                 }
  [03:02:30.657]             }
  [03:02:30.657]         }))
  [03:02:30.657]     }, error = function(ex) {
  [03:02:30.657]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:02:30.657]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:02:30.657]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:02:30.657]     }, finally = {
  [03:02:30.657]         {
  [03:02:30.657]             NULL
  [03:02:30.657]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:02:30.657]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:02:30.657]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:02:30.657]                 label = NULL, ...) 
  [03:02:30.657]             {
  [03:02:30.657]                 if (substitute) 
  [03:02:30.657]                   expr <- substitute(expr)
  [03:02:30.657]                 local <- as.logical(local)
  [03:02:30.657]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:02:30.657]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:02:30.657]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:02:30.657]                   label = label, ...)
  [03:02:30.657]                 if (!future$lazy) 
  [03:02:30.657]                   future <- run(future)
  [03:02:30.657]                 invisible(future)
  [03:02:30.657]             }), .cleanup = FALSE, .init = FALSE)
  [03:02:30.657]         }
  [03:02:30.657]         base::options(...future.oldOptions)
  [03:02:30.657]     })
  [03:02:30.657]     Sys.time
  [03:02:30.657]     if (base::is.na(TRUE)) {
  [03:02:30.657]     }
  [03:02:30.657]     else {
  [03:02:30.657]         base::sink(type = "output", split = FALSE)
  [03:02:30.657]         if (TRUE) {
  [03:02:30.657]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:02:30.657]         }
  [03:02:30.657]         else {
  [03:02:30.657]             ...future.result["stdout"] <- base::list(NULL)
  [03:02:30.657]         }
  [03:02:30.657]         base::close(...future.stdout)
  [03:02:30.657]         ...future.stdout <- NULL
  [03:02:30.657]     }
  [03:02:30.657]     ...future.result$conditions <- ...future.conditions
  [03:02:30.657]     ...future.result
  [03:02:30.657] }
  [03:02:30.666] plan(): Setting new future strategy stack:
  [03:02:30.667] List of future strategies:
  [03:02:30.667] 1. sequential:
  [03:02:30.667]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:02:30.667]    - tweaked: FALSE
  [03:02:30.667]    - call: NULL
  [03:02:30.668] plan(): nbrOfWorkers() = 1
  [03:02:30.670] plan(): Setting new future strategy stack:
  [03:02:30.671] List of future strategies:
  [03:02:30.671] 1. sequential:
  [03:02:30.671]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:02:30.671]    - tweaked: FALSE
  [03:02:30.671]    - call: plan(strategy, substitute = FALSE)
  [03:02:30.672] plan(): nbrOfWorkers() = 1
  [03:02:30.673] SequentialFuture started (and completed)
  [1] 6
  ** Sum function 'B' with plan('sequential') ...
  function (x, ...) 
  {
      sumt <- function(x) {
          message("Arguments '...' exists: ", exists("...", inherits = TRUE))
          y %<-% {
              sum(x, ...)
          }
          y
      }
      sumt(x)
  }
  <bytecode: 0x37b3748>
  Arguments '...' exists: TRUE
  [03:02:30.677] getGlobalsAndPackages() ...
  [03:02:30.678] Searching for globals...
  [03:02:30.683] - globals found: [4] '{', 'sum', 'x', '...'
  [03:02:30.684] Searching for globals ... DONE
  [03:02:30.684] Resolving globals: FALSE
  [03:02:30.685] Tweak future expression to call with '...' arguments ...
  [03:02:30.685] Tweak future expression to call with '...' arguments ... DONE
  [03:02:30.687] The total size of the 2 globals is 112 bytes (112 bytes)
  [03:02:30.688] - globals: [2] 'x', 'future.call.arguments'
  [03:02:30.688] 
  [03:02:30.689] getGlobalsAndPackages() ... DONE
  [03:02:30.691] Packages needed by the future expression (n = 0): <none>
  [03:02:30.692] Packages needed by future strategies (n = 0): <none>
  [03:02:30.701] {
  [03:02:30.701]     {
  [03:02:30.701]         ...future.startTime <- base::Sys.time()
  [03:02:30.701]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:02:30.701]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:02:30.701]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:02:30.701]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:02:30.701]             future.resolve.recursive = NULL, width = 80L)
  [03:02:30.701]         {
  [03:02:30.701]             {
  [03:02:30.701]                 base::local({
  [03:02:30.701]                   has_future <- base::requireNamespace("future", 
  [03:02:30.701]                     quietly = TRUE)
  [03:02:30.701]                   version <- if (has_future) 
  [03:02:30.701]                     utils::packageVersion("future")
  [03:02:30.701]                   else NULL
  [03:02:30.701]                   if (!has_future || version < "1.8.0") {
  [03:02:30.701]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:02:30.701]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:02:30.701]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:02:30.701]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:02:30.701]                         "release", "version")], collapse = " "), 
  [03:02:30.701]                       hostname = base::Sys.info()[["nodename"]])
  [03:02:30.701]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:02:30.701]                       info)
  [03:02:30.701]                     info <- base::paste(info, collapse = "; ")
  [03:02:30.701]                     if (!has_future) {
  [03:02:30.701]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:02:30.701]                         info)
  [03:02:30.701]                     }
  [03:02:30.701]                     else {
  [03:02:30.701]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:02:30.701]                         info, version)
  [03:02:30.701]                     }
  [03:02:30.701]                     base::stop(msg)
  [03:02:30.701]                   }
  [03:02:30.701]                 })
  [03:02:30.701]             }
  [03:02:30.701]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:02:30.701]         }
  [03:02:30.701]     }
  [03:02:30.701]     if (base::is.na(TRUE)) {
  [03:02:30.701]     }
  [03:02:30.701]     else {
  [03:02:30.701]         if (TRUE) {
  [03:02:30.701]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:02:30.701]                 open = "w")
  [03:02:30.701]         }
  [03:02:30.701]         else {
  [03:02:30.701]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:02:30.701]                 windows = "NUL", "/dev/null"), open = "w")
  [03:02:30.701]         }
  [03:02:30.701]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:02:30.701]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:02:30.701]             base::sink(type = "output", split = FALSE)
  [03:02:30.701]             base::close(...future.stdout)
  [03:02:30.701]         }, add = TRUE)
  [03:02:30.701]     }
  [03:02:30.701]     ...future.frame <- base::sys.nframe()
  [03:02:30.701]     ...future.conditions <- base::list()
  [03:02:30.701]     ...future.rng <- base::globalenv()$.Random.seed
  [03:02:30.701]     ...future.result <- base::tryCatch({
  [03:02:30.701]         base::withCallingHandlers({
  [03:02:30.701]             ...future.value <- base::withVisible(base::local({
  [03:02:30.701]                 sum(x, ...)
  [03:02:30.701]             }))
  [03:02:30.701]             future::FutureResult(value = ...future.value$value, 
  [03:02:30.701]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:02:30.701]                   ...future.rng), started = ...future.startTime, 
  [03:02:30.701]                 version = "1.8")
  [03:02:30.701]         }, condition = base::local({
  [03:02:30.701]             c <- base::c
  [03:02:30.701]             inherits <- base::inherits
  [03:02:30.701]             invokeRestart <- base::invokeRestart
  [03:02:30.701]             length <- base::length
  [03:02:30.701]             list <- base::list
  [03:02:30.701]             seq.int <- base::seq.int
  [03:02:30.701]             signalCondition <- base::signalCondition
  [03:02:30.701]             sys.calls <- base::sys.calls
  [03:02:30.701]             Sys.time <- base::Sys.time
  [03:02:30.701]             `[[` <- base::`[[`
  [03:02:30.701]             `+` <- base::`+`
  [03:02:30.701]             `<<-` <- base::`<<-`
  [03:02:30.701]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:02:30.701]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:02:30.701]                   3L)]
  [03:02:30.701]             }
  [03:02:30.701]             function(cond) {
  [03:02:30.701]                 if (inherits(cond, "error")) {
  [03:02:30.701]                   sessionInformation <- function() {
  [03:02:30.701]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:02:30.701]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:02:30.701]                       search = base::search(), system = base::Sys.info())
  [03:02:30.701]                   }
  [03:02:30.701]                   ...future.conditions[[length(...future.conditions) + 
  [03:02:30.701]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:02:30.701]                     cond$call), session = sessionInformation(), 
  [03:02:30.701]                     timestamp = Sys.time(), signaled = 0L)
  [03:02:30.701]                   signalCondition(cond)
  [03:02:30.701]                 }
  [03:02:30.701]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:02:30.701]                 ))) {
  [03:02:30.701]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:02:30.701]                   ...future.conditions[[length(...future.conditions) + 
  [03:02:30.701]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:02:30.701]                   if (!signal) {
  [03:02:30.701]                     muffleCondition <- function (cond) 
  [03:02:30.701]                     {
  [03:02:30.701]                       inherits <- base::inherits
  [03:02:30.701]                       invokeRestart <- base::invokeRestart
  [03:02:30.701]                       muffled <- FALSE
  [03:02:30.701]                       if (inherits(cond, "message")) {
  [03:02:30.701]                         invokeRestart("muffleMessage")
  [03:02:30.701]                         muffled <- TRUE
  [03:02:30.701]                       }
  [03:02:30.701]                       else if (inherits(cond, "warning")) {
  [03:02:30.701]                         invokeRestart("muffleWarning")
  [03:02:30.701]                         muffled <- TRUE
  [03:02:30.701]                       }
  [03:02:30.701]                       else if (inherits(cond, "condition")) {
  [03:02:30.701]                         computeRestarts <- base::computeRestarts
  [03:02:30.701]                         grepl <- base::grepl
  [03:02:30.701]                         is.null <- base::is.null
  [03:02:30.701]                         restarts <- computeRestarts(cond)
  [03:02:30.701]                         for (restart in restarts) {
  [03:02:30.701]                           name <- restart$name
  [03:02:30.701]                           if (is.null(name)) 
  [03:02:30.701]                             next
  [03:02:30.701]                           if (!grepl("^muffle", name)) 
  [03:02:30.701]                             next
  [03:02:30.701]                           invokeRestart(restart)
  [03:02:30.701]                           muffled <- TRUE
  [03:02:30.701]                           break
  [03:02:30.701]                         }
  [03:02:30.701]                       }
  [03:02:30.701]                       invisible(muffled)
  [03:02:30.701]                     }
  [03:02:30.701]                     muffleCondition(cond)
  [03:02:30.701]                   }
  [03:02:30.701]                 }
  [03:02:30.701]             }
  [03:02:30.701]         }))
  [03:02:30.701]     }, error = function(ex) {
  [03:02:30.701]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:02:30.701]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:02:30.701]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:02:30.701]     }, finally = {
  [03:02:30.701]         {
  [03:02:30.701]             NULL
  [03:02:30.701]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:02:30.701]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:02:30.701]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:02:30.701]                 label = NULL, ...) 
  [03:02:30.701]             {
  [03:02:30.701]                 if (substitute) 
  [03:02:30.701]                   expr <- substitute(expr)
  [03:02:30.701]                 local <- as.logical(local)
  [03:02:30.701]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:02:30.701]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:02:30.701]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:02:30.701]                   label = label, ...)
  [03:02:30.701]                 if (!future$lazy) 
  [03:02:30.701]                   future <- run(future)
  [03:02:30.701]                 invisible(future)
  [03:02:30.701]             }), .cleanup = FALSE, .init = FALSE)
  [03:02:30.701]         }
  [03:02:30.701]         base::options(...future.oldOptions)
  [03:02:30.701]     })
  [03:02:30.701]     Sys.time
  [03:02:30.701]     if (base::is.na(TRUE)) {
  [03:02:30.701]     }
  [03:02:30.701]     else {
  [03:02:30.701]         base::sink(type = "output", split = FALSE)
  [03:02:30.701]         if (TRUE) {
  [03:02:30.701]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:02:30.701]         }
  [03:02:30.701]         else {
  [03:02:30.701]             ...future.result["stdout"] <- base::list(NULL)
  [03:02:30.701]         }
  [03:02:30.701]         base::close(...future.stdout)
  [03:02:30.701]         ...future.stdout <- NULL
  [03:02:30.701]     }
  [03:02:30.701]     ...future.result$conditions <- ...future.conditions
  [03:02:30.701]     ...future.result
  [03:02:30.701] }
  [03:02:30.708] plan(): Setting new future strategy stack:
  [03:02:30.709] List of future strategies:
  [03:02:30.709] 1. sequential:
  [03:02:30.709]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:02:30.709]    - tweaked: FALSE
  [03:02:30.709]    - call: NULL
  [03:02:30.710] plan(): nbrOfWorkers() = 1
  [03:02:30.712] plan(): Setting new future strategy stack:
  [03:02:30.713] List of future strategies:
  [03:02:30.713] 1. sequential:
  [03:02:30.713]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:02:30.713]    - tweaked: FALSE
  [03:02:30.713]    - call: plan(strategy, substitute = FALSE)
  [03:02:30.714] plan(): nbrOfWorkers() = 1
  [03:02:30.715] SequentialFuture started (and completed)
  [1] 6
  ** Sum function 'C' with plan('sequential') ...
  function (x, y) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, y)
      }
      y
  }
  <bytecode: 0x21e6af8>
  Arguments '...' exists: FALSE
  [03:02:30.718] getGlobalsAndPackages() ...
  [03:02:30.718] Searching for globals...
  [03:02:30.722] - globals found: [4] '{', 'sum', 'x', 'y'
  [03:02:30.723] Searching for globals ... DONE
  [03:02:30.723] Resolving globals: FALSE
  [03:02:30.725] The total size of the 2 globals is 112 bytes (112 bytes)
  [03:02:30.725] - globals: [2] 'x', 'y'
  [03:02:30.726] 
  [03:02:30.726] getGlobalsAndPackages() ... DONE
  [03:02:30.729] Packages needed by the future expression (n = 0): <none>
  [03:02:30.730] Packages needed by future strategies (n = 0): <none>
  [03:02:30.738] {
  [03:02:30.738]     {
  [03:02:30.738]         ...future.startTime <- base::Sys.time()
  [03:02:30.738]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:02:30.738]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:02:30.738]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:02:30.738]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:02:30.738]             future.resolve.recursive = NULL, width = 80L)
  [03:02:30.738]         {
  [03:02:30.738]             {
  [03:02:30.738]                 base::local({
  [03:02:30.738]                   has_future <- base::requireNamespace("future", 
  [03:02:30.738]                     quietly = TRUE)
  [03:02:30.738]                   version <- if (has_future) 
  [03:02:30.738]                     utils::packageVersion("future")
  [03:02:30.738]                   else NULL
  [03:02:30.738]                   if (!has_future || version < "1.8.0") {
  [03:02:30.738]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:02:30.738]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:02:30.738]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:02:30.738]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:02:30.738]                         "release", "version")], collapse = " "), 
  [03:02:30.738]                       hostname = base::Sys.info()[["nodename"]])
  [03:02:30.738]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:02:30.738]                       info)
  [03:02:30.738]                     info <- base::paste(info, collapse = "; ")
  [03:02:30.738]                     if (!has_future) {
  [03:02:30.738]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:02:30.738]                         info)
  [03:02:30.738]                     }
  [03:02:30.738]                     else {
  [03:02:30.738]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:02:30.738]                         info, version)
  [03:02:30.738]                     }
  [03:02:30.738]                     base::stop(msg)
  [03:02:30.738]                   }
  [03:02:30.738]                 })
  [03:02:30.738]             }
  [03:02:30.738]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:02:30.738]         }
  [03:02:30.738]     }
  [03:02:30.738]     if (base::is.na(TRUE)) {
  [03:02:30.738]     }
  [03:02:30.738]     else {
  [03:02:30.738]         if (TRUE) {
  [03:02:30.738]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:02:30.738]                 open = "w")
  [03:02:30.738]         }
  [03:02:30.738]         else {
  [03:02:30.738]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:02:30.738]                 windows = "NUL", "/dev/null"), open = "w")
  [03:02:30.738]         }
  [03:02:30.738]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:02:30.738]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:02:30.738]             base::sink(type = "output", split = FALSE)
  [03:02:30.738]             base::close(...future.stdout)
  [03:02:30.738]         }, add = TRUE)
  [03:02:30.738]     }
  [03:02:30.738]     ...future.frame <- base::sys.nframe()
  [03:02:30.738]     ...future.conditions <- base::list()
  [03:02:30.738]     ...future.rng <- base::globalenv()$.Random.seed
  [03:02:30.738]     ...future.result <- base::tryCatch({
  [03:02:30.738]         base::withCallingHandlers({
  [03:02:30.738]             ...future.value <- base::withVisible(base::local({
  [03:02:30.738]                 sum(x, y)
  [03:02:30.738]             }))
  [03:02:30.738]             future::FutureResult(value = ...future.value$value, 
  [03:02:30.738]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:02:30.738]                   ...future.rng), started = ...future.startTime, 
  [03:02:30.738]                 version = "1.8")
  [03:02:30.738]         }, condition = base::local({
  [03:02:30.738]             c <- base::c
  [03:02:30.738]             inherits <- base::inherits
  [03:02:30.738]             invokeRestart <- base::invokeRestart
  [03:02:30.738]             length <- base::length
  [03:02:30.738]             list <- base::list
  [03:02:30.738]             seq.int <- base::seq.int
  [03:02:30.738]             signalCondition <- base::signalCondition
  [03:02:30.738]             sys.calls <- base::sys.calls
  [03:02:30.738]             Sys.time <- base::Sys.time
  [03:02:30.738]             `[[` <- base::`[[`
  [03:02:30.738]             `+` <- base::`+`
  [03:02:30.738]             `<<-` <- base::`<<-`
  [03:02:30.738]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:02:30.738]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:02:30.738]                   3L)]
  [03:02:30.738]             }
  [03:02:30.738]             function(cond) {
  [03:02:30.738]                 if (inherits(cond, "error")) {
  [03:02:30.738]                   sessionInformation <- function() {
  [03:02:30.738]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:02:30.738]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:02:30.738]                       search = base::search(), system = base::Sys.info())
  [03:02:30.738]                   }
  [03:02:30.738]                   ...future.conditions[[length(...future.conditions) + 
  [03:02:30.738]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:02:30.738]                     cond$call), session = sessionInformation(), 
  [03:02:30.738]                     timestamp = Sys.time(), signaled = 0L)
  [03:02:30.738]                   signalCondition(cond)
  [03:02:30.738]                 }
  [03:02:30.738]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:02:30.738]                 ))) {
  [03:02:30.738]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:02:30.738]                   ...future.conditions[[length(...future.conditions) + 
  [03:02:30.738]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:02:30.738]                   if (!signal) {
  [03:02:30.738]                     muffleCondition <- function (cond) 
  [03:02:30.738]                     {
  [03:02:30.738]                       inherits <- base::inherits
  [03:02:30.738]                       invokeRestart <- base::invokeRestart
  [03:02:30.738]                       muffled <- FALSE
  [03:02:30.738]                       if (inherits(cond, "message")) {
  [03:02:30.738]                         invokeRestart("muffleMessage")
  [03:02:30.738]                         muffled <- TRUE
  [03:02:30.738]                       }
  [03:02:30.738]                       else if (inherits(cond, "warning")) {
  [03:02:30.738]                         invokeRestart("muffleWarning")
  [03:02:30.738]                         muffled <- TRUE
  [03:02:30.738]                       }
  [03:02:30.738]                       else if (inherits(cond, "condition")) {
  [03:02:30.738]                         computeRestarts <- base::computeRestarts
  [03:02:30.738]                         grepl <- base::grepl
  [03:02:30.738]                         is.null <- base::is.null
  [03:02:30.738]                         restarts <- computeRestarts(cond)
  [03:02:30.738]                         for (restart in restarts) {
  [03:02:30.738]                           name <- restart$name
  [03:02:30.738]                           if (is.null(name)) 
  [03:02:30.738]                             next
  [03:02:30.738]                           if (!grepl("^muffle", name)) 
  [03:02:30.738]                             next
  [03:02:30.738]                           invokeRestart(restart)
  [03:02:30.738]                           muffled <- TRUE
  [03:02:30.738]                           break
  [03:02:30.738]                         }
  [03:02:30.738]                       }
  [03:02:30.738]                       invisible(muffled)
  [03:02:30.738]                     }
  [03:02:30.738]                     muffleCondition(cond)
  [03:02:30.738]                   }
  [03:02:30.738]                 }
  [03:02:30.738]             }
  [03:02:30.738]         }))
  [03:02:30.738]     }, error = function(ex) {
  [03:02:30.738]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:02:30.738]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:02:30.738]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:02:30.738]     }, finally = {
  [03:02:30.738]         {
  [03:02:30.738]             NULL
  [03:02:30.738]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:02:30.738]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:02:30.738]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:02:30.738]                 label = NULL, ...) 
  [03:02:30.738]             {
  [03:02:30.738]                 if (substitute) 
  [03:02:30.738]                   expr <- substitute(expr)
  [03:02:30.738]                 local <- as.logical(local)
  [03:02:30.738]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:02:30.738]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:02:30.738]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:02:30.738]                   label = label, ...)
  [03:02:30.738]                 if (!future$lazy) 
  [03:02:30.738]                   future <- run(future)
  [03:02:30.738]                 invisible(future)
  [03:02:30.738]             }), .cleanup = FALSE, .init = FALSE)
  [03:02:30.738]         }
  [03:02:30.738]         base::options(...future.oldOptions)
  [03:02:30.738]     })
  [03:02:30.738]     Sys.time
  [03:02:30.738]     if (base::is.na(TRUE)) {
  [03:02:30.738]     }
  [03:02:30.738]     else {
  [03:02:30.738]         base::sink(type = "output", split = FALSE)
  [03:02:30.738]         if (TRUE) {
  [03:02:30.738]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:02:30.738]         }
  [03:02:30.738]         else {
  [03:02:30.738]             ...future.result["stdout"] <- base::list(NULL)
  [03:02:30.738]         }
  [03:02:30.738]         base::close(...future.stdout)
  [03:02:30.738]         ...future.stdout <- NULL
  [03:02:30.738]     }
  [03:02:30.738]     ...future.result$conditions <- ...future.conditions
  [03:02:30.738]     ...future.result
  [03:02:30.738] }
  [03:02:30.745] plan(): Setting new future strategy stack:
  [03:02:30.745] List of future strategies:
  [03:02:30.745] 1. sequential:
  [03:02:30.745]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:02:30.745]    - tweaked: FALSE
  [03:02:30.745]    - call: NULL
  [03:02:30.746] plan(): nbrOfWorkers() = 1
  [03:02:30.748] plan(): Setting new future strategy stack:
  [03:02:30.749] List of future strategies:
  [03:02:30.749] 1. sequential:
  [03:02:30.749]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:02:30.749]    - tweaked: FALSE
  [03:02:30.749]    - call: plan(strategy, substitute = FALSE)
  [03:02:30.750] plan(): nbrOfWorkers() = 1
  [03:02:30.751] SequentialFuture started (and completed)
  [1] 6
  ** Sum function 'D' with plan('sequential') ...
  function (x, y) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, y, ...)
      }
      y
  }
  <bytecode: 0x192f0e0>
  Arguments '...' exists: FALSE
  [03:02:30.754] getGlobalsAndPackages() ...
  [03:02:30.754] Searching for globals...
  [03:02:30.759] - globals found: [5] '{', 'sum', 'x', 'y', '...'
  [03:02:30.759] Searching for globals ... DONE
  [03:02:30.760] Resolving globals: FALSE
  [03:02:30.760] Tweak future expression to call with '...' arguments ...
  [03:02:30.761] Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }
  Error in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  : 
    Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }
  [1] "Error in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  : \n  Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }\n"
  attr(,"class")
  [1] "try-error"
  attr(,"condition")
  <simpleError in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,     globals = globals): Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }>
  Testing with 1 cores ... DONE
  Testing with 2 cores ...
  *** Global argument '...' ...
  - plan('multicore') ...
  [03:02:30.794] plan(): Setting new future strategy stack:
  [03:02:30.795] List of future strategies:
  [03:02:30.795] 1. multicore:
  [03:02:30.795]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [03:02:30.795]    - tweaked: FALSE
  [03:02:30.795]    - call: plan(strategy, substitute = FALSE)
  [03:02:30.811] plan(): nbrOfWorkers() = 2
  ** Sum function 'A' with plan('multicore') ...
  function (x, ...) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, ...)
      }
      y
  }
  <bytecode: 0x33097b8>
  Arguments '...' exists: TRUE
  [03:02:30.813] getGlobalsAndPackages() ...
  [03:02:30.814] Searching for globals...
  [03:02:30.818] - globals found: [4] '{', 'sum', 'x', '...'
  [03:02:30.818] Searching for globals ... DONE
  [03:02:30.819] Resolving globals: FALSE
  [03:02:30.819] Tweak future expression to call with '...' arguments ...
  [03:02:30.820] Tweak future expression to call with '...' arguments ... DONE
  [03:02:30.834] The total size of the 2 globals is 112 bytes (112 bytes)
  [03:02:30.834] - globals: [2] 'x', 'future.call.arguments'
  [03:02:30.835] 
  [03:02:30.835] getGlobalsAndPackages() ... DONE
  [03:02:30.839] Packages needed by the future expression (n = 0): <none>
  [03:02:30.840] Packages needed by future strategies (n = 0): <none>
  [03:02:30.847] {
  [03:02:30.847]     {
  [03:02:30.847]         ...future.startTime <- base::Sys.time()
  [03:02:30.847]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:02:30.847]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:02:30.847]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:02:30.847]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:02:30.847]             future.resolve.recursive = NULL, width = 80L)
  [03:02:30.847]         {
  [03:02:30.847]             {
  [03:02:30.847]                 {
  [03:02:30.847]                   base::local({
  [03:02:30.847]                     has_future <- base::requireNamespace("future", 
  [03:02:30.847]                       quietly = TRUE)
  [03:02:30.847]                     version <- if (has_future) 
  [03:02:30.847]                       utils::packageVersion("future")
  [03:02:30.847]                     else NULL
  [03:02:30.847]                     if (!has_future || version < "1.8.0") {
  [03:02:30.847]                       info <- base::c(r_version = base::gsub("R version ", 
  [03:02:30.847]                         "", base::R.version$version.string), 
  [03:02:30.847]                         platform = base::sprintf("%s (%s-bit)", 
  [03:02:30.847]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:02:30.847]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:02:30.847]                           "release", "version")], collapse = " "), 
  [03:02:30.847]                         hostname = base::Sys.info()[["nodename"]])
  [03:02:30.847]                       info <- base::sprintf("%s: %s", base::names(info), 
  [03:02:30.847]                         info)
  [03:02:30.847]                       info <- base::paste(info, collapse = "; ")
  [03:02:30.847]                       if (!has_future) {
  [03:02:30.847]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:02:30.847]                           info)
  [03:02:30.847]                       }
  [03:02:30.847]                       else {
  [03:02:30.847]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:02:30.847]                           info, version)
  [03:02:30.847]                       }
  [03:02:30.847]                       base::stop(msg)
  [03:02:30.847]                     }
  [03:02:30.847]                   })
  [03:02:30.847]                 }
  [03:02:30.847]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [03:02:30.847]                 base::options(mc.cores = 1L)
  [03:02:30.847]             }
  [03:02:30.847]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:02:30.847]         }
  [03:02:30.847]     }
  [03:02:30.847]     if (base::is.na(TRUE)) {
  [03:02:30.847]     }
  [03:02:30.847]     else {
  [03:02:30.847]         if (TRUE) {
  [03:02:30.847]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:02:30.847]                 open = "w")
  [03:02:30.847]         }
  [03:02:30.847]         else {
  [03:02:30.847]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:02:30.847]                 windows = "NUL", "/dev/null"), open = "w")
  [03:02:30.847]         }
  [03:02:30.847]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:02:30.847]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:02:30.847]             base::sink(type = "output", split = FALSE)
  [03:02:30.847]             base::close(...future.stdout)
  [03:02:30.847]         }, add = TRUE)
  [03:02:30.847]     }
  [03:02:30.847]     ...future.frame <- base::sys.nframe()
  [03:02:30.847]     ...future.conditions <- base::list()
  [03:02:30.847]     ...future.rng <- base::globalenv()$.Random.seed
  [03:02:30.847]     ...future.result <- base::tryCatch({
  [03:02:30.847]         base::withCallingHandlers({
  [03:02:30.847]             ...future.value <- base::withVisible(base::local({
  [03:02:30.847]                 sum(x, ...)
  [03:02:30.847]             }))
  [03:02:30.847]             future::FutureResult(value = ...future.value$value, 
  [03:02:30.847]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:02:30.847]                   ...future.rng), started = ...future.startTime, 
  [03:02:30.847]                 version = "1.8")
  [03:02:30.847]         }, condition = base::local({
  [03:02:30.847]             c <- base::c
  [03:02:30.847]             inherits <- base::inherits
  [03:02:30.847]             invokeRestart <- base::invokeRestart
  [03:02:30.847]             length <- base::length
  [03:02:30.847]             list <- base::list
  [03:02:30.847]             seq.int <- base::seq.int
  [03:02:30.847]             signalCondition <- base::signalCondition
  [03:02:30.847]             sys.calls <- base::sys.calls
  [03:02:30.847]             Sys.time <- base::Sys.time
  [03:02:30.847]             `[[` <- base::`[[`
  [03:02:30.847]             `+` <- base::`+`
  [03:02:30.847]             `<<-` <- base::`<<-`
  [03:02:30.847]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:02:30.847]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:02:30.847]                   3L)]
  [03:02:30.847]             }
  [03:02:30.847]             function(cond) {
  [03:02:30.847]                 if (inherits(cond, "error")) {
  [03:02:30.847]                   sessionInformation <- function() {
  [03:02:30.847]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:02:30.847]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:02:30.847]                       search = base::search(), system = base::Sys.info())
  [03:02:30.847]                   }
  [03:02:30.847]                   ...future.conditions[[length(...future.conditions) + 
  [03:02:30.847]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:02:30.847]                     cond$call), session = sessionInformation(), 
  [03:02:30.847]                     timestamp = Sys.time(), signaled = 0L)
  [03:02:30.847]                   signalCondition(cond)
  [03:02:30.847]                 }
  [03:02:30.847]                 else if (inherits(cond, "condition")) {
  [03:02:30.847]                   signal <- FALSE && inherits(cond, character(0))
  [03:02:30.847]                   ...future.conditions[[length(...future.conditions) + 
  [03:02:30.847]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:02:30.847]                   if (!signal) {
  [03:02:30.847]                     muffleCondition <- function (cond) 
  [03:02:30.847]                     {
  [03:02:30.847]                       inherits <- base::inherits
  [03:02:30.847]                       invokeRestart <- base::invokeRestart
  [03:02:30.847]                       muffled <- FALSE
  [03:02:30.847]                       if (inherits(cond, "message")) {
  [03:02:30.847]                         invokeRestart("muffleMessage")
  [03:02:30.847]                         muffled <- TRUE
  [03:02:30.847]                       }
  [03:02:30.847]                       else if (inherits(cond, "warning")) {
  [03:02:30.847]                         invokeRestart("muffleWarning")
  [03:02:30.847]                         muffled <- TRUE
  [03:02:30.847]                       }
  [03:02:30.847]                       else if (inherits(cond, "condition")) {
  [03:02:30.847]                         computeRestarts <- base::computeRestarts
  [03:02:30.847]                         grepl <- base::grepl
  [03:02:30.847]                         is.null <- base::is.null
  [03:02:30.847]                         restarts <- computeRestarts(cond)
  [03:02:30.847]                         for (restart in restarts) {
  [03:02:30.847]                           name <- restart$name
  [03:02:30.847]                           if (is.null(name)) 
  [03:02:30.847]                             next
  [03:02:30.847]                           if (!grepl("^muffle", name)) 
  [03:02:30.847]                             next
  [03:02:30.847]                           invokeRestart(restart)
  [03:02:30.847]                           muffled <- TRUE
  [03:02:30.847]                           break
  [03:02:30.847]                         }
  [03:02:30.847]                       }
  [03:02:30.847]                       invisible(muffled)
  [03:02:30.847]                     }
  [03:02:30.847]                     muffleCondition(cond)
  [03:02:30.847]                   }
  [03:02:30.847]                 }
  [03:02:30.847]             }
  [03:02:30.847]         }))
  [03:02:30.847]     }, error = function(ex) {
  [03:02:30.847]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:02:30.847]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:02:30.847]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:02:30.847]     }, finally = {
  [03:02:30.847]         {
  [03:02:30.847]             {
  [03:02:30.847]                 base::options(mc.cores = ...future.mc.cores.old)
  [03:02:30.847]             }
  [03:02:30.847]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:02:30.847]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:02:30.847]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [03:02:30.847]                 earlySignal = FALSE, label = NULL, ...) 
  [03:02:30.847]             {
  [03:02:30.847]                 if (substitute) 
  [03:02:30.847]                   expr <- substitute(expr)
  [03:02:30.847]                 if (is.function(workers)) 
  [03:02:30.847]                   workers <- workers()
  [03:02:30.847]                 workers <- as.integer(workers)
  [03:02:30.847]                 stop_if_not(is.finite(workers), workers >= 1L)
  [03:02:30.847]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [03:02:30.847]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [03:02:30.847]                     lazy = lazy, seed = seed, globals = globals, 
  [03:02:30.847]                     local = TRUE, label = label, ...))
  [03:02:30.847]                 }
  [03:02:30.847]                 oopts <- options(mc.cores = workers)
  [03:02:30.847]                 on.exit(options(oopts))
  [03:02:30.847]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [03:02:30.847]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:02:30.847]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [03:02:30.847]                   label = label, ...)
  [03:02:30.847]                 if (!future$lazy) 
  [03:02:30.847]                   future <- run(future)
  [03:02:30.847]                 invisible(future)
  [03:02:30.847]             }), .cleanup = FALSE, .init = FALSE)
  [03:02:30.847]         }
  [03:02:30.847]         base::options(...future.oldOptions)
  [03:02:30.847]     })
  [03:02:30.847]     Sys.time
  [03:02:30.847]     if (base::is.na(TRUE)) {
  [03:02:30.847]     }
  [03:02:30.847]     else {
  [03:02:30.847]         base::sink(type = "output", split = FALSE)
  [03:02:30.847]         if (TRUE) {
  [03:02:30.847]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:02:30.847]         }
  [03:02:30.847]         else {
  [03:02:30.847]             ...future.result["stdout"] <- base::list(NULL)
  [03:02:30.847]         }
  [03:02:30.847]         base::close(...future.stdout)
  [03:02:30.847]         ...future.stdout <- NULL
  [03:02:30.847]     }
  [03:02:30.847]     ...future.result$conditions <- ...future.conditions
  [03:02:30.847]     ...future.result
  [03:02:30.847] }
  [03:02:30.853] requestCore(): workers = 2
  [03:02:30.861] MulticoreFuture started
  [03:02:30.877] plan(): Setting new future strategy stack:
  [03:02:30.878] List of future strategies:
  [03:02:30.878] 1. sequential:
  [03:02:30.878]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:02:30.878]    - tweaked: FALSE
  [03:02:30.878]    - call: NULL
  [03:02:30.881] plan(): nbrOfWorkers() = 1
  [03:02:30.883] plan(): Setting new future strategy stack:
  [03:02:30.884] List of future strategies:
  [03:02:30.884] 1. multicore:
  [03:02:30.884]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [03:02:30.884]    - tweaked: FALSE
  [03:02:30.884]    - call: plan(strategy, substitute = FALSE)
  [03:02:30.901] plan(): nbrOfWorkers() = 2
  [1] 6
  ** Sum function 'B' with plan('multicore') ...
  function (x, ...) 
  {
      sumt <- function(x) {
          message("Arguments '...' exists: ", exists("...", inherits = TRUE))
          y %<-% {
              sum(x, ...)
          }
          y
      }
      sumt(x)
  }
  <bytecode: 0x37b3748>
  Arguments '...' exists: TRUE
  [03:02:30.932] getGlobalsAndPackages() ...
  [03:02:30.932] Searching for globals...
  [03:02:30.937] - globals found: [4] '{', 'sum', 'x', '...'
  [03:02:30.938] Searching for globals ... DONE
  [03:02:30.938] Resolving globals: FALSE
  [03:02:30.939] Tweak future expression to call with '...' arguments ...
  [03:02:30.940] Tweak future expression to call with '...' arguments ... DONE
  [03:02:30.948] The total size of the 2 globals is 112 bytes (112 bytes)
  [03:02:30.949] - globals: [2] 'x', 'future.call.arguments'
  [03:02:30.949] 
  [03:02:30.950] getGlobalsAndPackages() ... DONE
  [03:02:30.954] Packages needed by the future expression (n = 0): <none>
  [03:02:30.955] Packages needed by future strategies (n = 0): <none>
  [03:02:30.976] {
  [03:02:30.976]     {
  [03:02:30.976]         ...future.startTime <- base::Sys.time()
  [03:02:30.976]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:02:30.976]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:02:30.976]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:02:30.976]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:02:30.976]             future.resolve.recursive = NULL, width = 80L)
  [03:02:30.976]         {
  [03:02:30.976]             {
  [03:02:30.976]                 {
  [03:02:30.976]                   base::local({
  [03:02:30.976]                     has_future <- base::requireNamespace("future", 
  [03:02:30.976]                       quietly = TRUE)
  [03:02:30.976]                     version <- if (has_future) 
  [03:02:30.976]                       utils::packageVersion("future")
  [03:02:30.976]                     else NULL
  [03:02:30.976]                     if (!has_future || version < "1.8.0") {
  [03:02:30.976]                       info <- base::c(r_version = base::gsub("R version ", 
  [03:02:30.976]                         "", base::R.version$version.string), 
  [03:02:30.976]                         platform = base::sprintf("%s (%s-bit)", 
  [03:02:30.976]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:02:30.976]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:02:30.976]                           "release", "version")], collapse = " "), 
  [03:02:30.976]                         hostname = base::Sys.info()[["nodename"]])
  [03:02:30.976]                       info <- base::sprintf("%s: %s", base::names(info), 
  [03:02:30.976]                         info)
  [03:02:30.976]                       info <- base::paste(info, collapse = "; ")
  [03:02:30.976]                       if (!has_future) {
  [03:02:30.976]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:02:30.976]                           info)
  [03:02:30.976]                       }
  [03:02:30.976]                       else {
  [03:02:30.976]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:02:30.976]                           info, version)
  [03:02:30.976]                       }
  [03:02:30.976]                       base::stop(msg)
  [03:02:30.976]                     }
  [03:02:30.976]                   })
  [03:02:30.976]                 }
  [03:02:30.976]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [03:02:30.976]                 base::options(mc.cores = 1L)
  [03:02:30.976]             }
  [03:02:30.976]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:02:30.976]         }
  [03:02:30.976]     }
  [03:02:30.976]     if (base::is.na(TRUE)) {
  [03:02:30.976]     }
  [03:02:30.976]     else {
  [03:02:30.976]         if (TRUE) {
  [03:02:30.976]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:02:30.976]                 open = "w")
  [03:02:30.976]         }
  [03:02:30.976]         else {
  [03:02:30.976]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:02:30.976]                 windows = "NUL", "/dev/null"), open = "w")
  [03:02:30.976]         }
  [03:02:30.976]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:02:30.976]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:02:30.976]             base::sink(type = "output", split = FALSE)
  [03:02:30.976]             base::close(...future.stdout)
  [03:02:30.976]         }, add = TRUE)
  [03:02:30.976]     }
  [03:02:30.976]     ...future.frame <- base::sys.nframe()
  [03:02:30.976]     ...future.conditions <- base::list()
  [03:02:30.976]     ...future.rng <- base::globalenv()$.Random.seed
  [03:02:30.976]     ...future.result <- base::tryCatch({
  [03:02:30.976]         base::withCallingHandlers({
  [03:02:30.976]             ...future.value <- base::withVisible(base::local({
  [03:02:30.976]                 sum(x, ...)
  [03:02:30.976]             }))
  [03:02:30.976]             future::FutureResult(value = ...future.value$value, 
  [03:02:30.976]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:02:30.976]                   ...future.rng), started = ...future.startTime, 
  [03:02:30.976]                 version = "1.8")
  [03:02:30.976]         }, condition = base::local({
  [03:02:30.976]             c <- base::c
  [03:02:30.976]             inherits <- base::inherits
  [03:02:30.976]             invokeRestart <- base::invokeRestart
  [03:02:30.976]             length <- base::length
  [03:02:30.976]             list <- base::list
  [03:02:30.976]             seq.int <- base::seq.int
  [03:02:30.976]             signalCondition <- base::signalCondition
  [03:02:30.976]             sys.calls <- base::sys.calls
  [03:02:30.976]             Sys.time <- base::Sys.time
  [03:02:30.976]             `[[` <- base::`[[`
  [03:02:30.976]             `+` <- base::`+`
  [03:02:30.976]             `<<-` <- base::`<<-`
  [03:02:30.976]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:02:30.976]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:02:30.976]                   3L)]
  [03:02:30.976]             }
  [03:02:30.976]             function(cond) {
  [03:02:30.976]                 if (inherits(cond, "error")) {
  [03:02:30.976]                   sessionInformation <- function() {
  [03:02:30.976]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:02:30.976]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:02:30.976]                       search = base::search(), system = base::Sys.info())
  [03:02:30.976]                   }
  [03:02:30.976]                   ...future.conditions[[length(...future.conditions) + 
  [03:02:30.976]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:02:30.976]                     cond$call), session = sessionInformation(), 
  [03:02:30.976]                     timestamp = Sys.time(), signaled = 0L)
  [03:02:30.976]                   signalCondition(cond)
  [03:02:30.976]                 }
  [03:02:30.976]                 else if (inherits(cond, "condition")) {
  [03:02:30.976]                   signal <- FALSE && inherits(cond, character(0))
  [03:02:30.976]                   ...future.conditions[[length(...future.conditions) + 
  [03:02:30.976]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:02:30.976]                   if (!signal) {
  [03:02:30.976]                     muffleCondition <- function (cond) 
  [03:02:30.976]                     {
  [03:02:30.976]                       inherits <- base::inherits
  [03:02:30.976]                       invokeRestart <- base::invokeRestart
  [03:02:30.976]                       muffled <- FALSE
  [03:02:30.976]                       if (inherits(cond, "message")) {
  [03:02:30.976]                         invokeRestart("muffleMessage")
  [03:02:30.976]                         muffled <- TRUE
  [03:02:30.976]                       }
  [03:02:30.976]                       else if (inherits(cond, "warning")) {
  [03:02:30.976]                         invokeRestart("muffleWarning")
  [03:02:30.976]                         muffled <- TRUE
  [03:02:30.976]                       }
  [03:02:30.976]                       else if (inherits(cond, "condition")) {
  [03:02:30.976]                         computeRestarts <- base::computeRestarts
  [03:02:30.976]                         grepl <- base::grepl
  [03:02:30.976]                         is.null <- base::is.null
  [03:02:30.976]                         restarts <- computeRestarts(cond)
  [03:02:30.976]                         for (restart in restarts) {
  [03:02:30.976]                           name <- restart$name
  [03:02:30.976]                           if (is.null(name)) 
  [03:02:30.976]                             next
  [03:02:30.976]                           if (!grepl("^muffle", name)) 
  [03:02:30.976]                             next
  [03:02:30.976]                           invokeRestart(restart)
  [03:02:30.976]                           muffled <- TRUE
  [03:02:30.976]                           break
  [03:02:30.976]                         }
  [03:02:30.976]                       }
  [03:02:30.976]                       invisible(muffled)
  [03:02:30.976]                     }
  [03:02:30.976]                     muffleCondition(cond)
  [03:02:30.976]                   }
  [03:02:30.976]                 }
  [03:02:30.976]             }
  [03:02:30.976]         }))
  [03:02:30.976]     }, error = function(ex) {
  [03:02:30.976]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:02:30.976]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:02:30.976]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:02:30.976]     }, finally = {
  [03:02:30.976]         {
  [03:02:30.976]             {
  [03:02:30.976]                 base::options(mc.cores = ...future.mc.cores.old)
  [03:02:30.976]             }
  [03:02:30.976]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:02:30.976]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:02:30.976]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [03:02:30.976]                 earlySignal = FALSE, label = NULL, ...) 
  [03:02:30.976]             {
  [03:02:30.976]                 if (substitute) 
  [03:02:30.976]                   expr <- substitute(expr)
  [03:02:30.976]                 if (is.function(workers)) 
  [03:02:30.976]                   workers <- workers()
  [03:02:30.976]                 workers <- as.integer(workers)
  [03:02:30.976]                 stop_if_not(is.finite(workers), workers >= 1L)
  [03:02:30.976]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [03:02:30.976]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [03:02:30.976]                     lazy = lazy, seed = seed, globals = globals, 
  [03:02:30.976]                     local = TRUE, label = label, ...))
  [03:02:30.976]                 }
  [03:02:30.976]                 oopts <- options(mc.cores = workers)
  [03:02:30.976]                 on.exit(options(oopts))
  [03:02:30.976]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [03:02:30.976]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:02:30.976]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [03:02:30.976]                   label = label, ...)
  [03:02:30.976]                 if (!future$lazy) 
  [03:02:30.976]                   future <- run(future)
  [03:02:30.976]                 invisible(future)
  [03:02:30.976]             }), .cleanup = FALSE, .init = FALSE)
  [03:02:30.976]         }
  [03:02:30.976]         base::options(...future.oldOptions)
  [03:02:30.976]     })
  [03:02:30.976]     Sys.time
  [03:02:30.976]     if (base::is.na(TRUE)) {
  [03:02:30.976]     }
  [03:02:30.976]     else {
  [03:02:30.976]         base::sink(type = "output", split = FALSE)
  [03:02:30.976]         if (TRUE) {
  [03:02:30.976]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:02:30.976]         }
  [03:02:30.976]         else {
  [03:02:30.976]             ...future.result["stdout"] <- base::list(NULL)
  [03:02:30.976]         }
  [03:02:30.976]         base::close(...future.stdout)
  [03:02:30.976]         ...future.stdout <- NULL
  [03:02:30.976]     }
  [03:02:30.976]     ...future.result$conditions <- ...future.conditions
  [03:02:30.976]     ...future.result
  [03:02:30.976] }
  [03:02:30.983] requestCore(): workers = 2
  [03:02:30.988] MulticoreFuture started
  [03:02:31.006] plan(): Setting new future strategy stack:
  [03:02:31.007] List of future strategies:
  [03:02:31.007] 1. sequential:
  [03:02:31.007]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:02:31.007]    - tweaked: FALSE
  [03:02:31.007]    - call: NULL
  [03:02:31.014] plan(): nbrOfWorkers() = 1
  [03:02:31.017] plan(): Setting new future strategy stack:
  [03:02:31.017] List of future strategies:
  [03:02:31.017] 1. multicore:
  [03:02:31.017]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [03:02:31.017]    - tweaked: FALSE
  [03:02:31.017]    - call: plan(strategy, substitute = FALSE)
  [03:02:31.021] plan(): nbrOfWorkers() = 2
  [1] 6
  ** Sum function 'C' with plan('multicore') ...
  function (x, y) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, y)
      }
      y
  }
  <bytecode: 0x21e6af8>
  Arguments '...' exists: FALSE
  [03:02:31.026] getGlobalsAndPackages() ...
  [03:02:31.027] Searching for globals...
  [03:02:31.032] - globals found: [4] '{', 'sum', 'x', 'y'
  [03:02:31.032] Searching for globals ... DONE
  [03:02:31.033] Resolving globals: FALSE
  [03:02:31.048] The total size of the 2 globals is 112 bytes (112 bytes)
  [03:02:31.049] - globals: [2] 'x', 'y'
  [03:02:31.049] 
  [03:02:31.050] getGlobalsAndPackages() ... DONE
  [03:02:31.054] Packages needed by the future expression (n = 0): <none>
  [03:02:31.054] Packages needed by future strategies (n = 0): <none>
  [03:02:31.076] {
  [03:02:31.076]     {
  [03:02:31.076]         ...future.startTime <- base::Sys.time()
  [03:02:31.076]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:02:31.076]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:02:31.076]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:02:31.076]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:02:31.076]             future.resolve.recursive = NULL, width = 80L)
  [03:02:31.076]         {
  [03:02:31.076]             {
  [03:02:31.076]                 {
  [03:02:31.076]                   base::local({
  [03:02:31.076]                     has_future <- base::requireNamespace("future", 
  [03:02:31.076]                       quietly = TRUE)
  [03:02:31.076]                     version <- if (has_future) 
  [03:02:31.076]                       utils::packageVersion("future")
  [03:02:31.076]                     else NULL
  [03:02:31.076]                     if (!has_future || version < "1.8.0") {
  [03:02:31.076]                       info <- base::c(r_version = base::gsub("R version ", 
  [03:02:31.076]                         "", base::R.version$version.string), 
  [03:02:31.076]                         platform = base::sprintf("%s (%s-bit)", 
  [03:02:31.076]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:02:31.076]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:02:31.076]                           "release", "version")], collapse = " "), 
  [03:02:31.076]                         hostname = base::Sys.info()[["nodename"]])
  [03:02:31.076]                       info <- base::sprintf("%s: %s", base::names(info), 
  [03:02:31.076]                         info)
  [03:02:31.076]                       info <- base::paste(info, collapse = "; ")
  [03:02:31.076]                       if (!has_future) {
  [03:02:31.076]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:02:31.076]                           info)
  [03:02:31.076]                       }
  [03:02:31.076]                       else {
  [03:02:31.076]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:02:31.076]                           info, version)
  [03:02:31.076]                       }
  [03:02:31.076]                       base::stop(msg)
  [03:02:31.076]                     }
  [03:02:31.076]                   })
  [03:02:31.076]                 }
  [03:02:31.076]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [03:02:31.076]                 base::options(mc.cores = 1L)
  [03:02:31.076]             }
  [03:02:31.076]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:02:31.076]         }
  [03:02:31.076]     }
  [03:02:31.076]     if (base::is.na(TRUE)) {
  [03:02:31.076]     }
  [03:02:31.076]     else {
  [03:02:31.076]         if (TRUE) {
  [03:02:31.076]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:02:31.076]                 open = "w")
  [03:02:31.076]         }
  [03:02:31.076]         else {
  [03:02:31.076]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:02:31.076]                 windows = "NUL", "/dev/null"), open = "w")
  [03:02:31.076]         }
  [03:02:31.076]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:02:31.076]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:02:31.076]             base::sink(type = "output", split = FALSE)
  [03:02:31.076]             base::close(...future.stdout)
  [03:02:31.076]         }, add = TRUE)
  [03:02:31.076]     }
  [03:02:31.076]     ...future.frame <- base::sys.nframe()
  [03:02:31.076]     ...future.conditions <- base::list()
  [03:02:31.076]     ...future.rng <- base::globalenv()$.Random.seed
  [03:02:31.076]     ...future.result <- base::tryCatch({
  [03:02:31.076]         base::withCallingHandlers({
  [03:02:31.076]             ...future.value <- base::withVisible(base::local({
  [03:02:31.076]                 sum(x, y)
  [03:02:31.076]             }))
  [03:02:31.076]             future::FutureResult(value = ...future.value$value, 
  [03:02:31.076]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:02:31.076]                   ...future.rng), started = ...future.startTime, 
  [03:02:31.076]                 version = "1.8")
  [03:02:31.076]         }, condition = base::local({
  [03:02:31.076]             c <- base::c
  [03:02:31.076]             inherits <- base::inherits
  [03:02:31.076]             invokeRestart <- base::invokeRestart
  [03:02:31.076]             length <- base::length
  [03:02:31.076]             list <- base::list
  [03:02:31.076]             seq.int <- base::seq.int
  [03:02:31.076]             signalCondition <- base::signalCondition
  [03:02:31.076]             sys.calls <- base::sys.calls
  [03:02:31.076]             Sys.time <- base::Sys.time
  [03:02:31.076]             `[[` <- base::`[[`
  [03:02:31.076]             `+` <- base::`+`
  [03:02:31.076]             `<<-` <- base::`<<-`
  [03:02:31.076]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:02:31.076]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:02:31.076]                   3L)]
  [03:02:31.076]             }
  [03:02:31.076]             function(cond) {
  [03:02:31.076]                 if (inherits(cond, "error")) {
  [03:02:31.076]                   sessionInformation <- function() {
  [03:02:31.076]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:02:31.076]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:02:31.076]                       search = base::search(), system = base::Sys.info())
  [03:02:31.076]                   }
  [03:02:31.076]                   ...future.conditions[[length(...future.conditions) + 
  [03:02:31.076]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:02:31.076]                     cond$call), session = sessionInformation(), 
  [03:02:31.076]                     timestamp = Sys.time(), signaled = 0L)
  [03:02:31.076]                   signalCondition(cond)
  [03:02:31.076]                 }
  [03:02:31.076]                 else if (inherits(cond, "condition")) {
  [03:02:31.076]                   signal <- FALSE && inherits(cond, character(0))
  [03:02:31.076]                   ...future.conditions[[length(...future.conditions) + 
  [03:02:31.076]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:02:31.076]                   if (!signal) {
  [03:02:31.076]                     muffleCondition <- function (cond) 
  [03:02:31.076]                     {
  [03:02:31.076]                       inherits <- base::inherits
  [03:02:31.076]                       invokeRestart <- base::invokeRestart
  [03:02:31.076]                       muffled <- FALSE
  [03:02:31.076]                       if (inherits(cond, "message")) {
  [03:02:31.076]                         invokeRestart("muffleMessage")
  [03:02:31.076]                         muffled <- TRUE
  [03:02:31.076]                       }
  [03:02:31.076]                       else if (inherits(cond, "warning")) {
  [03:02:31.076]                         invokeRestart("muffleWarning")
  [03:02:31.076]                         muffled <- TRUE
  [03:02:31.076]                       }
  [03:02:31.076]                       else if (inherits(cond, "condition")) {
  [03:02:31.076]                         computeRestarts <- base::computeRestarts
  [03:02:31.076]                         grepl <- base::grepl
  [03:02:31.076]                         is.null <- base::is.null
  [03:02:31.076]                         restarts <- computeRestarts(cond)
  [03:02:31.076]                         for (restart in restarts) {
  [03:02:31.076]                           name <- restart$name
  [03:02:31.076]                           if (is.null(name)) 
  [03:02:31.076]                             next
  [03:02:31.076]                           if (!grepl("^muffle", name)) 
  [03:02:31.076]                             next
  [03:02:31.076]                           invokeRestart(restart)
  [03:02:31.076]                           muffled <- TRUE
  [03:02:31.076]                           break
  [03:02:31.076]                         }
  [03:02:31.076]                       }
  [03:02:31.076]                       invisible(muffled)
  [03:02:31.076]                     }
  [03:02:31.076]                     muffleCondition(cond)
  [03:02:31.076]                   }
  [03:02:31.076]                 }
  [03:02:31.076]             }
  [03:02:31.076]         }))
  [03:02:31.076]     }, error = function(ex) {
  [03:02:31.076]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:02:31.076]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:02:31.076]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:02:31.076]     }, finally = {
  [03:02:31.076]         {
  [03:02:31.076]             {
  [03:02:31.076]                 base::options(mc.cores = ...future.mc.cores.old)
  [03:02:31.076]             }
  [03:02:31.076]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:02:31.076]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:02:31.076]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [03:02:31.076]                 earlySignal = FALSE, label = NULL, ...) 
  [03:02:31.076]             {
  [03:02:31.076]                 if (substitute) 
  [03:02:31.076]                   expr <- substitute(expr)
  [03:02:31.076]                 if (is.function(workers)) 
  [03:02:31.076]                   workers <- workers()
  [03:02:31.076]                 workers <- as.integer(workers)
  [03:02:31.076]                 stop_if_not(is.finite(workers), workers >= 1L)
  [03:02:31.076]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [03:02:31.076]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [03:02:31.076]                     lazy = lazy, seed = seed, globals = globals, 
  [03:02:31.076]                     local = TRUE, label = label, ...))
  [03:02:31.076]                 }
  [03:02:31.076]                 oopts <- options(mc.cores = workers)
  [03:02:31.076]                 on.exit(options(oopts))
  [03:02:31.076]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [03:02:31.076]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:02:31.076]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [03:02:31.076]                   label = label, ...)
  [03:02:31.076]                 if (!future$lazy) 
  [03:02:31.076]                   future <- run(future)
  [03:02:31.076]                 invisible(future)
  [03:02:31.076]             }), .cleanup = FALSE, .init = FALSE)
  [03:02:31.076]         }
  [03:02:31.076]         base::options(...future.oldOptions)
  [03:02:31.076]     })
  [03:02:31.076]     Sys.time
  [03:02:31.076]     if (base::is.na(TRUE)) {
  [03:02:31.076]     }
  [03:02:31.076]     else {
  [03:02:31.076]         base::sink(type = "output", split = FALSE)
  [03:02:31.076]         if (TRUE) {
  [03:02:31.076]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:02:31.076]         }
  [03:02:31.076]         else {
  [03:02:31.076]             ...future.result["stdout"] <- base::list(NULL)
  [03:02:31.076]         }
  [03:02:31.076]         base::close(...future.stdout)
  [03:02:31.076]         ...future.stdout <- NULL
  [03:02:31.076]     }
  [03:02:31.076]     ...future.result$conditions <- ...future.conditions
  [03:02:31.076]     ...future.result
  [03:02:31.076] }
  [03:02:31.082] requestCore(): workers = 2
  [03:02:31.107] MulticoreFuture started
  [03:02:31.124] plan(): Setting new future strategy stack:
  [03:02:31.126] List of future strategies:
  [03:02:31.126] 1. sequential:
  [03:02:31.126]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:02:31.126]    - tweaked: FALSE
  [03:02:31.126]    - call: NULL
  [03:02:31.128] plan(): nbrOfWorkers() = 1
  [03:02:31.132] plan(): Setting new future strategy stack:
  [03:02:31.132] List of future strategies:
  [03:02:31.132] 1. multicore:
  [03:02:31.132]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [03:02:31.132]    - tweaked: FALSE
  [03:02:31.132]    - call: plan(strategy, substitute = FALSE)
  [03:02:31.156] plan(): nbrOfWorkers() = 2
  [1] 6
  ** Sum function 'D' with plan('multicore') ...
  function (x, y) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, y, ...)
      }
      y
  }
  <bytecode: 0x192f0e0>
  Arguments '...' exists: FALSE
  [03:02:31.161] getGlobalsAndPackages() ...
  [03:02:31.162] Searching for globals...
  [03:02:31.168] - globals found: [5] '{', 'sum', 'x', 'y', '...'
  [03:02:31.168] Searching for globals ... DONE
  [03:02:31.169] Resolving globals: FALSE
  [03:02:31.170] Tweak future expression to call with '...' arguments ...
  [03:02:31.177] Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }
  Error in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  : 
    Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }
  [1] "Error in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  : \n  Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }\n"
  attr(,"class")
  [1] "try-error"
  attr(,"condition")
  <simpleError in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,     globals = globals): Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }>
  - plan('multisession') ...
  [03:02:31.180] plan(): Setting new future strategy stack:
  [03:02:31.180] List of future strategies:
  [03:02:31.180] 1. multisession:
  [03:02:31.180]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [03:02:31.180]    - tweaked: FALSE
  [03:02:31.180]    - call: plan(strategy, substitute = FALSE)
  [03:02:31.182] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [03:02:31.183] multisession:
  [03:02:31.183] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [03:02:31.183] - tweaked: FALSE
  [03:02:31.183] - call: plan(strategy, substitute = FALSE)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 22968
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/data/gannet/ripley/R/R-devel/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/RtmpUTnJFI/future.parent=69318.10ec61f2809bc.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpxHETCY/working_dir/RtmpUTnJFI/future.parent=69318.10ec61f2809bc.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/dotdotdot.R:gannet.stats.ox.ac.uk:ripley:69318' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/RtmpUTnJFI/future.parent=69318.10ec61f2809bc.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=22968 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  Error in get(name, envir = asNamespace(pkg), inherits = FALSE) : 
    object '.slaveRSOCK' not found
  Calls: ::: -> get
  Execution halted
  Killing worker process (PID 69433) if still alive
  [03:04:32.307] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(69318, signal = 0L)
  [1] TRUE
  Call: tools::pskill(69318, signal = 0L)
  [1] TRUE
  [03:04:32.308] - success
  [03:04:32.309] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 69433) was successfully killed: TRUE
  Error in makeRestartList(...) : 
    Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gannet.stats.ox.ac.uk'.
   * The error produced by socketConnection() was: 'reached elapsed time limit' (which suggests that the connection timeout of 120 seconds (argument 'connectTimeout') kicked in)
   * The localhost socket connection that failed to connect to the R worker used port 22968 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/dotdotdot.R:gannet.stats.ox.ac.uk:ripley:69318' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/RtmpUTnJFI/future.parent=69318.10ec61f2809bc.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=22968 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 69433) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted
Running the tests in ‘tests/early-signaling.R’ failed.
Complete output:
  > source("incl/start.R")
  [03:04:33.223] plan(): Setting new future strategy stack:
  [03:04:33.225] List of future strategies:
  [03:04:33.225] 1. sequential:
  [03:04:33.225]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:04:33.225]    - tweaked: FALSE
  [03:04:33.225]    - call: future::plan("sequential")
  [03:04:33.227] plan(): nbrOfWorkers() = 1
  > 
  > options(future.debug = FALSE)
  > 
  > message("*** Early signaling of conditions ...")
  *** Early signaling of conditions ...
  > 
  > message("*** Early signaling of conditions with sequential futures ...")
  *** Early signaling of conditions with sequential futures ...
  > 
  > plan(sequential)
  > f <- future({ stop("bang!") })
  > r <- resolved(f)
  > stopifnot(r)
  > v <- tryCatch(value(f), error = identity)
  > stopifnot(inherits(v, "error"))
  > 
  > message("- with lazy evaluation ...")
  - with lazy evaluation ...
  > f <- future({ stop("bang!") }, lazy = TRUE)
  > r <- resolved(f)
  > stopifnot(r)
  > v <- tryCatch(value(f), error = identity)
  > stopifnot(inherits(v, "error"))
  > 
  > plan(sequential, earlySignal = TRUE)
  > f <- tryCatch(future({ stop("bang!") }), error = identity)
  > stopifnot(inherits(f, "error"))
  > 
  > message("- with lazy evaluation ...")
  - with lazy evaluation ...
  > 
  > ## Errors
  > f <- future({ stop("bang!") }, lazy = TRUE)
  > r <- tryCatch(resolved(f), error = identity)
  > stopifnot(inherits(r, "error"))
  > v <- tryCatch(value(f), error = identity)
  > stopifnot(inherits(v, "error"))
  > 
  > ## Warnings
  > f <- future({ warning("careful!") }, lazy = TRUE)
  > res <- tryCatch({
  +   r <- resolved(f)
  + }, condition = function(w) w)
  > str(res)
  List of 2
   $ message: chr "careful!"
   $ call   : language eval(quote({     warning("careful!") ...
   - attr(*, "class")= chr [1:3] "simpleWarning" "warning" "condition"
  > stopifnot(inherits(res, "warning"))
  > 
  > ## Messages
  > f <- future({ message("hey!") }, lazy = TRUE)
  > res <- tryCatch({
  +   r <- resolved(f)
  + }, condition = function(w) w)
  > stopifnot(inherits(res, "message"))
  > 
  > ## Condition
  > f <- future({ signalCondition(simpleCondition("hmm")) }, lazy = TRUE)
  > res <- tryCatch({
  +   r <- resolved(f)
  + }, condition = function(w) w)
  > stopifnot(inherits(res, "condition"))
  > 
  > message("*** Early signaling of conditions with sequential futures ... DONE")
  *** Early signaling of conditions with sequential futures ... DONE
  > 
  > 
  > message("Number of available cores: ", availableCores())
  Number of available cores: 2
  > 
  > message("*** Early signaling of conditions with multisession futures ...")
  *** Early signaling of conditions with multisession futures ...
  > 
  > plan(multisession)
  Error in get(name, envir = asNamespace(pkg), inherits = FALSE) : 
    object '.slaveRSOCK' not found
  Calls: ::: -> get
  Execution halted
  Error in makeRestartList(...) : 
    Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gannet.stats.ox.ac.uk'.
   * The error produced by socketConnection() was: 'reached elapsed time limit' (which suggests that the connection timeout of 120 seconds (argument 'connectTimeout') kicked in)
   * The localhost socket connection that failed to connect to the R worker used port 36616 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/early-signaling.R:gannet.stats.ox.ac.uk:ripley:83958' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpxHETCY/working_dir/RtmpG7VKHI/future.parent=83958.147f64294cf0d.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=36616 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 84109) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'verbose=TRUE' to see more details.
     - Suggestion #2: Set 'outfile=NULL' to see output from worker.
  Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted
Running the tests in ‘tests/futureAssign.R’ failed.
Complete output:
  > source("incl/start.R")
  [03:06:41.172] plan(): Setting new future strategy stack:
  [03:06:41.174] List of future strategies:
  [03:06:41.174] 1. sequential:
  [03:06:41.174]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:41.174]    - tweaked: FALSE
  [03:06:41.174]    - call: future::plan("sequential")
  [03:06:41.181] plan(): nbrOfWorkers() = 1
  > 
  > message("*** futureAssign() ...")
  *** futureAssign() ...
  > 
  > message("*** futureAssign() - sequential w/ lazy evaluation ...")
  *** futureAssign() - sequential w/ lazy evaluation ...
  > 
  > delayedAssign("a", {
  +   cat("Delayed assignment evaluated\n")
  +   1
  + })
  > 
  > futureAssign("b", {
  +   cat("Future assignment evaluated\n")
  +   2
  + }, lazy = TRUE)
  [03:06:41.257] getGlobalsAndPackages() ...
  [03:06:41.257] Searching for globals...
  [03:06:41.290] - globals found: [2] '{', 'cat'
  [03:06:41.291] Searching for globals ... DONE
  [03:06:41.292] Resolving globals: FALSE
  [03:06:41.293] 
  [03:06:41.297] 
  [03:06:41.297] getGlobalsAndPackages() ... DONE
  > 
  > ## Because "lazy future" is used, the expression/value
  > ## for 'b' will not be resolved at the point.  For other
  > ## types of futures, it may already have been resolved
  > cat(sprintf("b = %s\n", b))
  [03:06:41.308] Packages needed by the future expression (n = 0): <none>
  [03:06:41.313] Packages needed by future strategies (n = 0): <none>
  [03:06:41.334] {
  [03:06:41.334]     {
  [03:06:41.334]         ...future.startTime <- base::Sys.time()
  [03:06:41.334]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:06:41.334]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:06:41.334]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [03:06:41.334]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:06:41.334]             future.resolve.recursive = NULL, width = 80L)
  [03:06:41.334]         {
  [03:06:41.334]             {
  [03:06:41.334]                 base::local({
  [03:06:41.334]                   has_future <- base::requireNamespace("future", 
  [03:06:41.334]                     quietly = TRUE)
  [03:06:41.334]                   version <- if (has_future) 
  [03:06:41.334]                     utils::packageVersion("future")
  [03:06:41.334]                   else NULL
  [03:06:41.334]                   if (!has_future || version < "1.8.0") {
  [03:06:41.334]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:06:41.334]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:06:41.334]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:06:41.334]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:06:41.334]                         "release", "version")], collapse = " "), 
  [03:06:41.334]                       hostname = base::Sys.info()[["nodename"]])
  [03:06:41.334]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:06:41.334]                       info)
  [03:06:41.334]                     info <- base::paste(info, collapse = "; ")
  [03:06:41.334]                     if (!has_future) {
  [03:06:41.334]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:06:41.334]                         info)
  [03:06:41.334]                     }
  [03:06:41.334]                     else {
  [03:06:41.334]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:06:41.334]                         info, version)
  [03:06:41.334]                     }
  [03:06:41.334]                     base::stop(msg)
  [03:06:41.334]                   }
  [03:06:41.334]                 })
  [03:06:41.334]             }
  [03:06:41.334]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:06:41.334]         }
  [03:06:41.334]     }
  [03:06:41.334]     if (base::is.na(TRUE)) {
  [03:06:41.334]     }
  [03:06:41.334]     else {
  [03:06:41.334]         if (TRUE) {
  [03:06:41.334]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:06:41.334]                 open = "w")
  [03:06:41.334]         }
  [03:06:41.334]         else {
  [03:06:41.334]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:06:41.334]                 windows = "NUL", "/dev/null"), open = "w")
  [03:06:41.334]         }
  [03:06:41.334]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:06:41.334]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:06:41.334]             base::sink(type = "output", split = FALSE)
  [03:06:41.334]             base::close(...future.stdout)
  [03:06:41.334]         }, add = TRUE)
  [03:06:41.334]     }
  [03:06:41.334]     ...future.frame <- base::sys.nframe()
  [03:06:41.334]     ...future.conditions <- base::list()
  [03:06:41.334]     ...future.rng <- base::globalenv()$.Random.seed
  [03:06:41.334]     ...future.result <- base::tryCatch({
  [03:06:41.334]         base::withCallingHandlers({
  [03:06:41.334]             ...future.value <- base::withVisible(base::local({
  [03:06:41.334]                 cat("Future assignment evaluated\n")
  [03:06:41.334]                 2
  [03:06:41.334]             }))
  [03:06:41.334]             future::FutureResult(value = ...future.value$value, 
  [03:06:41.334]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:41.334]                   ...future.rng), started = ...future.startTime, 
  [03:06:41.334]                 version = "1.8")
  [03:06:41.334]         }, condition = base::local({
  [03:06:41.334]             c <- base::c
  [03:06:41.334]             inherits <- base::inherits
  [03:06:41.334]             invokeRestart <- base::invokeRestart
  [03:06:41.334]             length <- base::length
  [03:06:41.334]             list <- base::list
  [03:06:41.334]             seq.int <- base::seq.int
  [03:06:41.334]             signalCondition <- base::signalCondition
  [03:06:41.334]             sys.calls <- base::sys.calls
  [03:06:41.334]             Sys.time <- base::Sys.time
  [03:06:41.334]             `[[` <- base::`[[`
  [03:06:41.334]             `+` <- base::`+`
  [03:06:41.334]             `<<-` <- base::`<<-`
  [03:06:41.334]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:06:41.334]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:06:41.334]                   3L)]
  [03:06:41.334]             }
  [03:06:41.334]             function(cond) {
  [03:06:41.334]                 if (inherits(cond, "error")) {
  [03:06:41.334]                   sessionInformation <- function() {
  [03:06:41.334]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:06:41.334]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:06:41.334]                       search = base::search(), system = base::Sys.info())
  [03:06:41.334]                   }
  [03:06:41.334]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:41.334]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:06:41.334]                     cond$call), session = sessionInformation(), 
  [03:06:41.334]                     timestamp = Sys.time(), signaled = 0L)
  [03:06:41.334]                   signalCondition(cond)
  [03:06:41.334]                 }
  [03:06:41.334]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:06:41.334]                 ))) {
  [03:06:41.334]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:06:41.334]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:41.334]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:06:41.334]                   if (!signal) {
  [03:06:41.334]                     muffleCondition <- function (cond) 
  [03:06:41.334]                     {
  [03:06:41.334]                       inherits <- base::inherits
  [03:06:41.334]                       invokeRestart <- base::invokeRestart
  [03:06:41.334]                       muffled <- FALSE
  [03:06:41.334]                       if (inherits(cond, "message")) {
  [03:06:41.334]                         invokeRestart("muffleMessage")
  [03:06:41.334]                         muffled <- TRUE
  [03:06:41.334]                       }
  [03:06:41.334]                       else if (inherits(cond, "warning")) {
  [03:06:41.334]                         invokeRestart("muffleWarning")
  [03:06:41.334]                         muffled <- TRUE
  [03:06:41.334]                       }
  [03:06:41.334]                       else if (inherits(cond, "condition")) {
  [03:06:41.334]                         computeRestarts <- base::computeRestarts
  [03:06:41.334]                         grepl <- base::grepl
  [03:06:41.334]                         is.null <- base::is.null
  [03:06:41.334]                         restarts <- computeRestarts(cond)
  [03:06:41.334]                         for (restart in restarts) {
  [03:06:41.334]                           name <- restart$name
  [03:06:41.334]                           if (is.null(name)) 
  [03:06:41.334]                             next
  [03:06:41.334]                           if (!grepl("^muffle", name)) 
  [03:06:41.334]                             next
  [03:06:41.334]                           invokeRestart(restart)
  [03:06:41.334]                           muffled <- TRUE
  [03:06:41.334]                           break
  [03:06:41.334]                         }
  [03:06:41.334]                       }
  [03:06:41.334]                       invisible(muffled)
  [03:06:41.334]                     }
  [03:06:41.334]                     muffleCondition(cond)
  [03:06:41.334]                   }
  [03:06:41.334]                 }
  [03:06:41.334]             }
  [03:06:41.334]         }))
  [03:06:41.334]     }, error = function(ex) {
  [03:06:41.334]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:06:41.334]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:41.334]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:06:41.334]     }, finally = {
  [03:06:41.334]         {
  [03:06:41.334]             NULL
  [03:06:41.334]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:06:41.334]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:06:41.334]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:06:41.334]                 label = NULL, ...) 
  [03:06:41.334]             {
  [03:06:41.334]                 if (substitute) 
  [03:06:41.334]                   expr <- substitute(expr)
  [03:06:41.334]                 local <- as.logical(local)
  [03:06:41.334]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:06:41.334]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:06:41.334]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:06:41.334]                   label = label, ...)
  [03:06:41.334]                 if (!future$lazy) 
  [03:06:41.334]                   future <- run(future)
  [03:06:41.334]                 invisible(future)
  [03:06:41.334]             }), .cleanup = FALSE, .init = FALSE)
  [03:06:41.334]         }
  [03:06:41.334]         base::options(...future.oldOptions)
  [03:06:41.334]     })
  [03:06:41.334]     Sys.time
  [03:06:41.334]     if (base::is.na(TRUE)) {
  [03:06:41.334]     }
  [03:06:41.334]     else {
  [03:06:41.334]         base::sink(type = "output", split = FALSE)
  [03:06:41.334]         if (TRUE) {
  [03:06:41.334]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:06:41.334]         }
  [03:06:41.334]         else {
  [03:06:41.334]             ...future.result["stdout"] <- base::list(NULL)
  [03:06:41.334]         }
  [03:06:41.334]         base::close(...future.stdout)
  [03:06:41.334]         ...future.stdout <- NULL
  [03:06:41.334]     }
  [03:06:41.334]     ...future.result$conditions <- ...future.conditions
  [03:06:41.334]     ...future.result
  [03:06:41.334] }
  [03:06:41.351] plan(): Setting new future strategy stack:
  [03:06:41.351] List of future strategies:
  [03:06:41.351] 1. sequential:
  [03:06:41.351]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:41.351]    - tweaked: FALSE
  [03:06:41.351]    - call: NULL
  [03:06:41.353] plan(): nbrOfWorkers() = 1
  [03:06:41.363] plan(): Setting new future strategy stack:
  [03:06:41.364] List of future strategies:
  [03:06:41.364] 1. sequential:
  [03:06:41.364]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:41.364]    - tweaked: FALSE
  [03:06:41.364]    - call: future::plan("sequential")
  [03:06:41.369] plan(): nbrOfWorkers() = 1
  [03:06:41.371] SequentialFuture started (and completed)
  Future assignment evaluated
  b = 2
  > 
  > ## The expression/value of 'a' is resolved at this point,
  > ## because a delayed assignment (promise) was used.
  > cat(sprintf("a = %s\n", a))
  Delayed assignment evaluated
  a = 1
  > 
  > stopifnot(identical(a, 1))
  > stopifnot(identical(b, 2))
  > 
  > message("*** futureAssign() - sequential w/ lazy evaluation ... DONE")
  *** futureAssign() - sequential w/ lazy evaluation ... DONE
  > 
  > 
  > message("*** futureAssign() - lazy = TRUE / FALSE ...")
  *** futureAssign() - lazy = TRUE / FALSE ...
  > 
  > for (cores in 1:availCores) {
  +   ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
  +   if (!fullTest && isWin32) next
  +   
  +   message(sprintf("Testing with %d cores ...", cores))
  +   options(mc.cores = cores)
  + 
  +   for (strategy in supportedStrategies(cores)) {
  +     message(sprintf("*** futureAssign() with %s futures ...", sQuote(strategy)))
  +     plan(strategy)
  + 
  +     ## Potential task name clashes
  +     u <- new.env()
  +     v <- new.env()
  +     futureAssign("a", { 2 }, assign.env = u)
  +     futureAssign("a", { 4 }, assign.env = v)
  +     
  +     cat(sprintf("u$a = %s\n", u$a))
  +     cat(sprintf("v$a = %s\n", v$a))
  +     
  +     stopifnot(identical(u$a, 2))
  +     stopifnot(identical(v$a, 4))
  +     
  +     
  +     ## Global variables
  +     a <- 1
  +     futureAssign("b", { 2 * a })
  +     a <- 2
  +     stopifnot(b == 2)
  + 
  +     ## Explicit lazy evaluation
  +     for (lazy in c(FALSE, TRUE)) {
  +       a <- 1
  +       f <- futureAssign("b", { 2 * a }, lazy = lazy)
  +       a <- 2
  +       stopifnot(b == 2)
  +       stopifnot(f$lazy == lazy || (strategy %in% c("multisession", "multiprocess") && cores == 1L))
  +       
  +       ## Set 'lazy' via disposable option
  +       options(future.disposable = list(lazy = lazy))
  +       a <- 1
  +       f <- futureAssign("b", { 2 * a })
  +       a <- 2
  +       stopifnot(b == 2)
  +       stopifnot(f$lazy == lazy || (strategy %in% c("multisession", "multiprocess") && cores == 1L))
  +     }
  + 
  +     message(sprintf("*** futureAssign() with %s futures ... DONE", sQuote(strategy)))
  +   } # for (strategy in ...)
  + 
  +   message(sprintf("Testing with %d cores ... DONE", cores))
  + } ## for (cores ...)
  Testing with 1 cores ...
  *** futureAssign() with 'sequential' futures ...
  [03:06:41.643] plan(): Setting new future strategy stack:
  [03:06:41.644] List of future strategies:
  [03:06:41.644] 1. sequential:
  [03:06:41.644]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:41.644]    - tweaked: FALSE
  [03:06:41.644]    - call: plan(strategy)
  [03:06:41.762] plan(): nbrOfWorkers() = 1
  [03:06:41.763] getGlobalsAndPackages() ...
  [03:06:41.764] Searching for globals...
  [03:06:41.781] - globals found: [1] '{'
  [03:06:41.782] Searching for globals ... DONE
  [03:06:41.782] Resolving globals: FALSE
  [03:06:41.783] 
  [03:06:41.784] 
  [03:06:41.784] getGlobalsAndPackages() ... DONE
  [03:06:41.797] Packages needed by the future expression (n = 0): <none>
  [03:06:41.798] Packages needed by future strategies (n = 0): <none>
  [03:06:41.820] {
  [03:06:41.820]     {
  [03:06:41.820]         ...future.startTime <- base::Sys.time()
  [03:06:41.820]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:06:41.820]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:06:41.820]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:06:41.820]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:06:41.820]             future.resolve.recursive = NULL, width = 80L)
  [03:06:41.820]         {
  [03:06:41.820]             {
  [03:06:41.820]                 base::local({
  [03:06:41.820]                   has_future <- base::requireNamespace("future", 
  [03:06:41.820]                     quietly = TRUE)
  [03:06:41.820]                   version <- if (has_future) 
  [03:06:41.820]                     utils::packageVersion("future")
  [03:06:41.820]                   else NULL
  [03:06:41.820]                   if (!has_future || version < "1.8.0") {
  [03:06:41.820]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:06:41.820]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:06:41.820]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:06:41.820]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:06:41.820]                         "release", "version")], collapse = " "), 
  [03:06:41.820]                       hostname = base::Sys.info()[["nodename"]])
  [03:06:41.820]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:06:41.820]                       info)
  [03:06:41.820]                     info <- base::paste(info, collapse = "; ")
  [03:06:41.820]                     if (!has_future) {
  [03:06:41.820]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:06:41.820]                         info)
  [03:06:41.820]                     }
  [03:06:41.820]                     else {
  [03:06:41.820]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:06:41.820]                         info, version)
  [03:06:41.820]                     }
  [03:06:41.820]                     base::stop(msg)
  [03:06:41.820]                   }
  [03:06:41.820]                 })
  [03:06:41.820]             }
  [03:06:41.820]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:06:41.820]         }
  [03:06:41.820]     }
  [03:06:41.820]     if (base::is.na(TRUE)) {
  [03:06:41.820]     }
  [03:06:41.820]     else {
  [03:06:41.820]         if (TRUE) {
  [03:06:41.820]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:06:41.820]                 open = "w")
  [03:06:41.820]         }
  [03:06:41.820]         else {
  [03:06:41.820]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:06:41.820]                 windows = "NUL", "/dev/null"), open = "w")
  [03:06:41.820]         }
  [03:06:41.820]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:06:41.820]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:06:41.820]             base::sink(type = "output", split = FALSE)
  [03:06:41.820]             base::close(...future.stdout)
  [03:06:41.820]         }, add = TRUE)
  [03:06:41.820]     }
  [03:06:41.820]     ...future.frame <- base::sys.nframe()
  [03:06:41.820]     ...future.conditions <- base::list()
  [03:06:41.820]     ...future.rng <- base::globalenv()$.Random.seed
  [03:06:41.820]     ...future.result <- base::tryCatch({
  [03:06:41.820]         base::withCallingHandlers({
  [03:06:41.820]             ...future.value <- base::withVisible(base::local({
  [03:06:41.820]                 2
  [03:06:41.820]             }))
  [03:06:41.820]             future::FutureResult(value = ...future.value$value, 
  [03:06:41.820]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:41.820]                   ...future.rng), started = ...future.startTime, 
  [03:06:41.820]                 version = "1.8")
  [03:06:41.820]         }, condition = base::local({
  [03:06:41.820]             c <- base::c
  [03:06:41.820]             inherits <- base::inherits
  [03:06:41.820]             invokeRestart <- base::invokeRestart
  [03:06:41.820]             length <- base::length
  [03:06:41.820]             list <- base::list
  [03:06:41.820]             seq.int <- base::seq.int
  [03:06:41.820]             signalCondition <- base::signalCondition
  [03:06:41.820]             sys.calls <- base::sys.calls
  [03:06:41.820]             Sys.time <- base::Sys.time
  [03:06:41.820]             `[[` <- base::`[[`
  [03:06:41.820]             `+` <- base::`+`
  [03:06:41.820]             `<<-` <- base::`<<-`
  [03:06:41.820]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:06:41.820]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:06:41.820]                   3L)]
  [03:06:41.820]             }
  [03:06:41.820]             function(cond) {
  [03:06:41.820]                 if (inherits(cond, "error")) {
  [03:06:41.820]                   sessionInformation <- function() {
  [03:06:41.820]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:06:41.820]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:06:41.820]                       search = base::search(), system = base::Sys.info())
  [03:06:41.820]                   }
  [03:06:41.820]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:41.820]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:06:41.820]                     cond$call), session = sessionInformation(), 
  [03:06:41.820]                     timestamp = Sys.time(), signaled = 0L)
  [03:06:41.820]                   signalCondition(cond)
  [03:06:41.820]                 }
  [03:06:41.820]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:06:41.820]                 ))) {
  [03:06:41.820]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:06:41.820]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:41.820]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:06:41.820]                   if (!signal) {
  [03:06:41.820]                     muffleCondition <- function (cond) 
  [03:06:41.820]                     {
  [03:06:41.820]                       inherits <- base::inherits
  [03:06:41.820]                       invokeRestart <- base::invokeRestart
  [03:06:41.820]                       muffled <- FALSE
  [03:06:41.820]                       if (inherits(cond, "message")) {
  [03:06:41.820]                         invokeRestart("muffleMessage")
  [03:06:41.820]                         muffled <- TRUE
  [03:06:41.820]                       }
  [03:06:41.820]                       else if (inherits(cond, "warning")) {
  [03:06:41.820]                         invokeRestart("muffleWarning")
  [03:06:41.820]                         muffled <- TRUE
  [03:06:41.820]                       }
  [03:06:41.820]                       else if (inherits(cond, "condition")) {
  [03:06:41.820]                         computeRestarts <- base::computeRestarts
  [03:06:41.820]                         grepl <- base::grepl
  [03:06:41.820]                         is.null <- base::is.null
  [03:06:41.820]                         restarts <- computeRestarts(cond)
  [03:06:41.820]                         for (restart in restarts) {
  [03:06:41.820]                           name <- restart$name
  [03:06:41.820]                           if (is.null(name)) 
  [03:06:41.820]                             next
  [03:06:41.820]                           if (!grepl("^muffle", name)) 
  [03:06:41.820]                             next
  [03:06:41.820]                           invokeRestart(restart)
  [03:06:41.820]                           muffled <- TRUE
  [03:06:41.820]                           break
  [03:06:41.820]                         }
  [03:06:41.820]                       }
  [03:06:41.820]                       invisible(muffled)
  [03:06:41.820]                     }
  [03:06:41.820]                     muffleCondition(cond)
  [03:06:41.820]                   }
  [03:06:41.820]                 }
  [03:06:41.820]             }
  [03:06:41.820]         }))
  [03:06:41.820]     }, error = function(ex) {
  [03:06:41.820]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:06:41.820]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:41.820]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:06:41.820]     }, finally = {
  [03:06:41.820]         {
  [03:06:41.820]             NULL
  [03:06:41.820]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:06:41.820]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:06:41.820]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:06:41.820]                 label = NULL, ...) 
  [03:06:41.820]             {
  [03:06:41.820]                 if (substitute) 
  [03:06:41.820]                   expr <- substitute(expr)
  [03:06:41.820]                 local <- as.logical(local)
  [03:06:41.820]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:06:41.820]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:06:41.820]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:06:41.820]                   label = label, ...)
  [03:06:41.820]                 if (!future$lazy) 
  [03:06:41.820]                   future <- run(future)
  [03:06:41.820]                 invisible(future)
  [03:06:41.820]             }), .cleanup = FALSE, .init = FALSE)
  [03:06:41.820]         }
  [03:06:41.820]         base::options(...future.oldOptions)
  [03:06:41.820]     })
  [03:06:41.820]     Sys.time
  [03:06:41.820]     if (base::is.na(TRUE)) {
  [03:06:41.820]     }
  [03:06:41.820]     else {
  [03:06:41.820]         base::sink(type = "output", split = FALSE)
  [03:06:41.820]         if (TRUE) {
  [03:06:41.820]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:06:41.820]         }
  [03:06:41.820]         else {
  [03:06:41.820]             ...future.result["stdout"] <- base::list(NULL)
  [03:06:41.820]         }
  [03:06:41.820]         base::close(...future.stdout)
  [03:06:41.820]         ...future.stdout <- NULL
  [03:06:41.820]     }
  [03:06:41.820]     ...future.result$conditions <- ...future.conditions
  [03:06:41.820]     ...future.result
  [03:06:41.820] }
  [03:06:41.835] plan(): Setting new future strategy stack:
  [03:06:41.835] List of future strategies:
  [03:06:41.835] 1. sequential:
  [03:06:41.835]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:41.835]    - tweaked: FALSE
  [03:06:41.835]    - call: NULL
  [03:06:41.837] plan(): nbrOfWorkers() = 1
  [03:06:41.843] plan(): Setting new future strategy stack:
  [03:06:41.843] List of future strategies:
  [03:06:41.843] 1. sequential:
  [03:06:41.843]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:41.843]    - tweaked: FALSE
  [03:06:41.843]    - call: plan(strategy)
  [03:06:41.845] plan(): nbrOfWorkers() = 1
  [03:06:41.846] SequentialFuture started (and completed)
  [03:06:41.851] getGlobalsAndPackages() ...
  [03:06:41.852] Searching for globals...
  [03:06:41.853] - globals found: [1] '{'
  [03:06:41.854] Searching for globals ... DONE
  [03:06:41.860] Resolving globals: FALSE
  [03:06:41.861] 
  [03:06:41.861] 
  [03:06:41.862] getGlobalsAndPackages() ... DONE
  [03:06:41.870] Packages needed by the future expression (n = 0): <none>
  [03:06:41.871] Packages needed by future strategies (n = 0): <none>
  [03:06:41.887] {
  [03:06:41.887]     {
  [03:06:41.887]         ...future.startTime <- base::Sys.time()
  [03:06:41.887]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:06:41.887]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:06:41.887]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:06:41.887]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:06:41.887]             future.resolve.recursive = NULL, width = 80L)
  [03:06:41.887]         {
  [03:06:41.887]             {
  [03:06:41.887]                 base::local({
  [03:06:41.887]                   has_future <- base::requireNamespace("future", 
  [03:06:41.887]                     quietly = TRUE)
  [03:06:41.887]                   version <- if (has_future) 
  [03:06:41.887]                     utils::packageVersion("future")
  [03:06:41.887]                   else NULL
  [03:06:41.887]                   if (!has_future || version < "1.8.0") {
  [03:06:41.887]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:06:41.887]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:06:41.887]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:06:41.887]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:06:41.887]                         "release", "version")], collapse = " "), 
  [03:06:41.887]                       hostname = base::Sys.info()[["nodename"]])
  [03:06:41.887]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:06:41.887]                       info)
  [03:06:41.887]                     info <- base::paste(info, collapse = "; ")
  [03:06:41.887]                     if (!has_future) {
  [03:06:41.887]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:06:41.887]                         info)
  [03:06:41.887]                     }
  [03:06:41.887]                     else {
  [03:06:41.887]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:06:41.887]                         info, version)
  [03:06:41.887]                     }
  [03:06:41.887]                     base::stop(msg)
  [03:06:41.887]                   }
  [03:06:41.887]                 })
  [03:06:41.887]             }
  [03:06:41.887]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:06:41.887]         }
  [03:06:41.887]     }
  [03:06:41.887]     if (base::is.na(TRUE)) {
  [03:06:41.887]     }
  [03:06:41.887]     else {
  [03:06:41.887]         if (TRUE) {
  [03:06:41.887]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:06:41.887]                 open = "w")
  [03:06:41.887]         }
  [03:06:41.887]         else {
  [03:06:41.887]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:06:41.887]                 windows = "NUL", "/dev/null"), open = "w")
  [03:06:41.887]         }
  [03:06:41.887]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:06:41.887]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:06:41.887]             base::sink(type = "output", split = FALSE)
  [03:06:41.887]             base::close(...future.stdout)
  [03:06:41.887]         }, add = TRUE)
  [03:06:41.887]     }
  [03:06:41.887]     ...future.frame <- base::sys.nframe()
  [03:06:41.887]     ...future.conditions <- base::list()
  [03:06:41.887]     ...future.rng <- base::globalenv()$.Random.seed
  [03:06:41.887]     ...future.result <- base::tryCatch({
  [03:06:41.887]         base::withCallingHandlers({
  [03:06:41.887]             ...future.value <- base::withVisible(base::local({
  [03:06:41.887]                 4
  [03:06:41.887]             }))
  [03:06:41.887]             future::FutureResult(value = ...future.value$value, 
  [03:06:41.887]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:41.887]                   ...future.rng), started = ...future.startTime, 
  [03:06:41.887]                 version = "1.8")
  [03:06:41.887]         }, condition = base::local({
  [03:06:41.887]             c <- base::c
  [03:06:41.887]             inherits <- base::inherits
  [03:06:41.887]             invokeRestart <- base::invokeRestart
  [03:06:41.887]             length <- base::length
  [03:06:41.887]             list <- base::list
  [03:06:41.887]             seq.int <- base::seq.int
  [03:06:41.887]             signalCondition <- base::signalCondition
  [03:06:41.887]             sys.calls <- base::sys.calls
  [03:06:41.887]             Sys.time <- base::Sys.time
  [03:06:41.887]             `[[` <- base::`[[`
  [03:06:41.887]             `+` <- base::`+`
  [03:06:41.887]             `<<-` <- base::`<<-`
  [03:06:41.887]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:06:41.887]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:06:41.887]                   3L)]
  [03:06:41.887]             }
  [03:06:41.887]             function(cond) {
  [03:06:41.887]                 if (inherits(cond, "error")) {
  [03:06:41.887]                   sessionInformation <- function() {
  [03:06:41.887]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:06:41.887]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:06:41.887]                       search = base::search(), system = base::Sys.info())
  [03:06:41.887]                   }
  [03:06:41.887]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:41.887]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:06:41.887]                     cond$call), session = sessionInformation(), 
  [03:06:41.887]                     timestamp = Sys.time(), signaled = 0L)
  [03:06:41.887]                   signalCondition(cond)
  [03:06:41.887]                 }
  [03:06:41.887]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:06:41.887]                 ))) {
  [03:06:41.887]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:06:41.887]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:41.887]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:06:41.887]                   if (!signal) {
  [03:06:41.887]                     muffleCondition <- function (cond) 
  [03:06:41.887]                     {
  [03:06:41.887]                       inherits <- base::inherits
  [03:06:41.887]                       invokeRestart <- base::invokeRestart
  [03:06:41.887]                       muffled <- FALSE
  [03:06:41.887]                       if (inherits(cond, "message")) {
  [03:06:41.887]                         invokeRestart("muffleMessage")
  [03:06:41.887]                         muffled <- TRUE
  [03:06:41.887]                       }
  [03:06:41.887]                       else if (inherits(cond, "warning")) {
  [03:06:41.887]                         invokeRestart("muffleWarning")
  [03:06:41.887]                         muffled <- TRUE
  [03:06:41.887]                       }
  [03:06:41.887]                       else if (inherits(cond, "condition")) {
  [03:06:41.887]                         computeRestarts <- base::computeRestarts
  [03:06:41.887]                         grepl <- base::grepl
  [03:06:41.887]                         is.null <- base::is.null
  [03:06:41.887]                         restarts <- computeRestarts(cond)
  [03:06:41.887]                         for (restart in restarts) {
  [03:06:41.887]                           name <- restart$name
  [03:06:41.887]                           if (is.null(name)) 
  [03:06:41.887]                             next
  [03:06:41.887]                           if (!grepl("^muffle", name)) 
  [03:06:41.887]                             next
  [03:06:41.887]                           invokeRestart(restart)
  [03:06:41.887]                           muffled <- TRUE
  [03:06:41.887]                           break
  [03:06:41.887]                         }
  [03:06:41.887]                       }
  [03:06:41.887]                       invisible(muffled)
  [03:06:41.887]                     }
  [03:06:41.887]                     muffleCondition(cond)
  [03:06:41.887]                   }
  [03:06:41.887]                 }
  [03:06:41.887]             }
  [03:06:41.887]         }))
  [03:06:41.887]     }, error = function(ex) {
  [03:06:41.887]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:06:41.887]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:41.887]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:06:41.887]     }, finally = {
  [03:06:41.887]         {
  [03:06:41.887]             NULL
  [03:06:41.887]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:06:41.887]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:06:41.887]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:06:41.887]                 label = NULL, ...) 
  [03:06:41.887]             {
  [03:06:41.887]                 if (substitute) 
  [03:06:41.887]                   expr <- substitute(expr)
  [03:06:41.887]                 local <- as.logical(local)
  [03:06:41.887]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:06:41.887]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:06:41.887]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:06:41.887]                   label = label, ...)
  [03:06:41.887]                 if (!future$lazy) 
  [03:06:41.887]                   future <- run(future)
  [03:06:41.887]                 invisible(future)
  [03:06:41.887]             }), .cleanup = FALSE, .init = FALSE)
  [03:06:41.887]         }
  [03:06:41.887]         base::options(...future.oldOptions)
  [03:06:41.887]     })
  [03:06:41.887]     Sys.time
  [03:06:41.887]     if (base::is.na(TRUE)) {
  [03:06:41.887]     }
  [03:06:41.887]     else {
  [03:06:41.887]         base::sink(type = "output", split = FALSE)
  [03:06:41.887]         if (TRUE) {
  [03:06:41.887]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:06:41.887]         }
  [03:06:41.887]         else {
  [03:06:41.887]             ...future.result["stdout"] <- base::list(NULL)
  [03:06:41.887]         }
  [03:06:41.887]         base::close(...future.stdout)
  [03:06:41.887]         ...future.stdout <- NULL
  [03:06:41.887]     }
  [03:06:41.887]     ...future.result$conditions <- ...future.conditions
  [03:06:41.887]     ...future.result
  [03:06:41.887] }
  [03:06:41.898] plan(): Setting new future strategy stack:
  [03:06:41.899] List of future strategies:
  [03:06:41.899] 1. sequential:
  [03:06:41.899]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:41.899]    - tweaked: FALSE
  [03:06:41.899]    - call: NULL
  [03:06:41.900] plan(): nbrOfWorkers() = 1
  [03:06:41.916] plan(): Setting new future strategy stack:
  [03:06:41.926] List of future strategies:
  [03:06:41.926] 1. sequential:
  [03:06:41.926]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:41.926]    - tweaked: FALSE
  [03:06:41.926]    - call: plan(strategy)
  [03:06:41.927] plan(): nbrOfWorkers() = 1
  [03:06:41.928] SequentialFuture started (and completed)
  u$a = 2
  v$a = 4
  [03:06:41.930] getGlobalsAndPackages() ...
  [03:06:41.930] Searching for globals...
  [03:06:41.947] - globals found: [3] '{', '*', 'a'
  [03:06:41.948] Searching for globals ... DONE
  [03:06:41.948] Resolving globals: FALSE
  [03:06:41.954] The total size of the 1 globals is 56 bytes (56 bytes)
  [03:06:41.955] - globals: [1] 'a'
  [03:06:41.956] 
  [03:06:41.956] getGlobalsAndPackages() ... DONE
  [03:06:41.963] Packages needed by the future expression (n = 0): <none>
  [03:06:41.964] Packages needed by future strategies (n = 0): <none>
  [03:06:41.982] {
  [03:06:41.982]     {
  [03:06:41.982]         ...future.startTime <- base::Sys.time()
  [03:06:41.982]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:06:41.982]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:06:41.982]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:06:41.982]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:06:41.982]             future.resolve.recursive = NULL, width = 80L)
  [03:06:41.982]         {
  [03:06:41.982]             {
  [03:06:41.982]                 base::local({
  [03:06:41.982]                   has_future <- base::requireNamespace("future", 
  [03:06:41.982]                     quietly = TRUE)
  [03:06:41.982]                   version <- if (has_future) 
  [03:06:41.982]                     utils::packageVersion("future")
  [03:06:41.982]                   else NULL
  [03:06:41.982]                   if (!has_future || version < "1.8.0") {
  [03:06:41.982]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:06:41.982]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:06:41.982]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:06:41.982]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:06:41.982]                         "release", "version")], collapse = " "), 
  [03:06:41.982]                       hostname = base::Sys.info()[["nodename"]])
  [03:06:41.982]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:06:41.982]                       info)
  [03:06:41.982]                     info <- base::paste(info, collapse = "; ")
  [03:06:41.982]                     if (!has_future) {
  [03:06:41.982]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:06:41.982]                         info)
  [03:06:41.982]                     }
  [03:06:41.982]                     else {
  [03:06:41.982]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:06:41.982]                         info, version)
  [03:06:41.982]                     }
  [03:06:41.982]                     base::stop(msg)
  [03:06:41.982]                   }
  [03:06:41.982]                 })
  [03:06:41.982]             }
  [03:06:41.982]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:06:41.982]         }
  [03:06:41.982]     }
  [03:06:41.982]     if (base::is.na(TRUE)) {
  [03:06:41.982]     }
  [03:06:41.982]     else {
  [03:06:41.982]         if (TRUE) {
  [03:06:41.982]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:06:41.982]                 open = "w")
  [03:06:41.982]         }
  [03:06:41.982]         else {
  [03:06:41.982]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:06:41.982]                 windows = "NUL", "/dev/null"), open = "w")
  [03:06:41.982]         }
  [03:06:41.982]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:06:41.982]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:06:41.982]             base::sink(type = "output", split = FALSE)
  [03:06:41.982]             base::close(...future.stdout)
  [03:06:41.982]         }, add = TRUE)
  [03:06:41.982]     }
  [03:06:41.982]     ...future.frame <- base::sys.nframe()
  [03:06:41.982]     ...future.conditions <- base::list()
  [03:06:41.982]     ...future.rng <- base::globalenv()$.Random.seed
  [03:06:41.982]     ...future.result <- base::tryCatch({
  [03:06:41.982]         base::withCallingHandlers({
  [03:06:41.982]             ...future.value <- base::withVisible(base::local({
  [03:06:41.982]                 2 * a
  [03:06:41.982]             }))
  [03:06:41.982]             future::FutureResult(value = ...future.value$value, 
  [03:06:41.982]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:41.982]                   ...future.rng), started = ...future.startTime, 
  [03:06:41.982]                 version = "1.8")
  [03:06:41.982]         }, condition = base::local({
  [03:06:41.982]             c <- base::c
  [03:06:41.982]             inherits <- base::inherits
  [03:06:41.982]             invokeRestart <- base::invokeRestart
  [03:06:41.982]             length <- base::length
  [03:06:41.982]             list <- base::list
  [03:06:41.982]             seq.int <- base::seq.int
  [03:06:41.982]             signalCondition <- base::signalCondition
  [03:06:41.982]             sys.calls <- base::sys.calls
  [03:06:41.982]             Sys.time <- base::Sys.time
  [03:06:41.982]             `[[` <- base::`[[`
  [03:06:41.982]             `+` <- base::`+`
  [03:06:41.982]             `<<-` <- base::`<<-`
  [03:06:41.982]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:06:41.982]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:06:41.982]                   3L)]
  [03:06:41.982]             }
  [03:06:41.982]             function(cond) {
  [03:06:41.982]                 if (inherits(cond, "error")) {
  [03:06:41.982]                   sessionInformation <- function() {
  [03:06:41.982]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:06:41.982]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:06:41.982]                       search = base::search(), system = base::Sys.info())
  [03:06:41.982]                   }
  [03:06:41.982]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:41.982]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:06:41.982]                     cond$call), session = sessionInformation(), 
  [03:06:41.982]                     timestamp = Sys.time(), signaled = 0L)
  [03:06:41.982]                   signalCondition(cond)
  [03:06:41.982]                 }
  [03:06:41.982]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:06:41.982]                 ))) {
  [03:06:41.982]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:06:41.982]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:41.982]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:06:41.982]                   if (!signal) {
  [03:06:41.982]                     muffleCondition <- function (cond) 
  [03:06:41.982]                     {
  [03:06:41.982]                       inherits <- base::inherits
  [03:06:41.982]                       invokeRestart <- base::invokeRestart
  [03:06:41.982]                       muffled <- FALSE
  [03:06:41.982]                       if (inherits(cond, "message")) {
  [03:06:41.982]                         invokeRestart("muffleMessage")
  [03:06:41.982]                         muffled <- TRUE
  [03:06:41.982]                       }
  [03:06:41.982]                       else if (inherits(cond, "warning")) {
  [03:06:41.982]                         invokeRestart("muffleWarning")
  [03:06:41.982]                         muffled <- TRUE
  [03:06:41.982]                       }
  [03:06:41.982]                       else if (inherits(cond, "condition")) {
  [03:06:41.982]                         computeRestarts <- base::computeRestarts
  [03:06:41.982]                         grepl <- base::grepl
  [03:06:41.982]                         is.null <- base::is.null
  [03:06:41.982]                         restarts <- computeRestarts(cond)
  [03:06:41.982]                         for (restart in restarts) {
  [03:06:41.982]                           name <- restart$name
  [03:06:41.982]                           if (is.null(name)) 
  [03:06:41.982]                             next
  [03:06:41.982]                           if (!grepl("^muffle", name)) 
  [03:06:41.982]                             next
  [03:06:41.982]                           invokeRestart(restart)
  [03:06:41.982]                           muffled <- TRUE
  [03:06:41.982]                           break
  [03:06:41.982]                         }
  [03:06:41.982]                       }
  [03:06:41.982]                       invisible(muffled)
  [03:06:41.982]                     }
  [03:06:41.982]                     muffleCondition(cond)
  [03:06:41.982]                   }
  [03:06:41.982]                 }
  [03:06:41.982]             }
  [03:06:41.982]         }))
  [03:06:41.982]     }, error = function(ex) {
  [03:06:41.982]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:06:41.982]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:41.982]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:06:41.982]     }, finally = {
  [03:06:41.982]         {
  [03:06:41.982]             NULL
  [03:06:41.982]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:06:41.982]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:06:41.982]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:06:41.982]                 label = NULL, ...) 
  [03:06:41.982]             {
  [03:06:41.982]                 if (substitute) 
  [03:06:41.982]                   expr <- substitute(expr)
  [03:06:41.982]                 local <- as.logical(local)
  [03:06:41.982]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:06:41.982]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:06:41.982]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:06:41.982]                   label = label, ...)
  [03:06:41.982]                 if (!future$lazy) 
  [03:06:41.982]                   future <- run(future)
  [03:06:41.982]                 invisible(future)
  [03:06:41.982]             }), .cleanup = FALSE, .init = FALSE)
  [03:06:41.982]         }
  [03:06:41.982]         base::options(...future.oldOptions)
  [03:06:41.982]     })
  [03:06:41.982]     Sys.time
  [03:06:41.982]     if (base::is.na(TRUE)) {
  [03:06:41.982]     }
  [03:06:41.982]     else {
  [03:06:41.982]         base::sink(type = "output", split = FALSE)
  [03:06:41.982]         if (TRUE) {
  [03:06:41.982]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:06:41.982]         }
  [03:06:41.982]         else {
  [03:06:41.982]             ...future.result["stdout"] <- base::list(NULL)
  [03:06:41.982]         }
  [03:06:41.982]         base::close(...future.stdout)
  [03:06:41.982]         ...future.stdout <- NULL
  [03:06:41.982]     }
  [03:06:41.982]     ...future.result$conditions <- ...future.conditions
  [03:06:41.982]     ...future.result
  [03:06:41.982] }
  [03:06:41.995] plan(): Setting new future strategy stack:
  [03:06:41.999] List of future strategies:
  [03:06:41.999] 1. sequential:
  [03:06:41.999]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:41.999]    - tweaked: FALSE
  [03:06:41.999]    - call: NULL
  [03:06:42.001] plan(): nbrOfWorkers() = 1
  [03:06:42.003] plan(): Setting new future strategy stack:
  [03:06:42.008] List of future strategies:
  [03:06:42.008] 1. sequential:
  [03:06:42.008]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:42.008]    - tweaked: FALSE
  [03:06:42.008]    - call: plan(strategy)
  [03:06:42.009] plan(): nbrOfWorkers() = 1
  [03:06:42.010] SequentialFuture started (and completed)
  [03:06:42.011] getGlobalsAndPackages() ...
  [03:06:42.012] Searching for globals...
  [03:06:42.018] - globals found: [3] '{', '*', 'a'
  [03:06:42.019] Searching for globals ... DONE
  [03:06:42.020] Resolving globals: FALSE
  [03:06:42.021] The total size of the 1 globals is 56 bytes (56 bytes)
  [03:06:42.029] - globals: [1] 'a'
  [03:06:42.030] 
  [03:06:42.030] getGlobalsAndPackages() ... DONE
  [03:06:42.037] Packages needed by the future expression (n = 0): <none>
  [03:06:42.038] Packages needed by future strategies (n = 0): <none>
  [03:06:42.054] {
  [03:06:42.054]     {
  [03:06:42.054]         ...future.startTime <- base::Sys.time()
  [03:06:42.054]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:06:42.054]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:06:42.054]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:06:42.054]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:06:42.054]             future.resolve.recursive = NULL, width = 80L)
  [03:06:42.054]         {
  [03:06:42.054]             {
  [03:06:42.054]                 base::local({
  [03:06:42.054]                   has_future <- base::requireNamespace("future", 
  [03:06:42.054]                     quietly = TRUE)
  [03:06:42.054]                   version <- if (has_future) 
  [03:06:42.054]                     utils::packageVersion("future")
  [03:06:42.054]                   else NULL
  [03:06:42.054]                   if (!has_future || version < "1.8.0") {
  [03:06:42.054]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:06:42.054]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:06:42.054]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:06:42.054]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:06:42.054]                         "release", "version")], collapse = " "), 
  [03:06:42.054]                       hostname = base::Sys.info()[["nodename"]])
  [03:06:42.054]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:06:42.054]                       info)
  [03:06:42.054]                     info <- base::paste(info, collapse = "; ")
  [03:06:42.054]                     if (!has_future) {
  [03:06:42.054]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:06:42.054]                         info)
  [03:06:42.054]                     }
  [03:06:42.054]                     else {
  [03:06:42.054]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:06:42.054]                         info, version)
  [03:06:42.054]                     }
  [03:06:42.054]                     base::stop(msg)
  [03:06:42.054]                   }
  [03:06:42.054]                 })
  [03:06:42.054]             }
  [03:06:42.054]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:06:42.054]         }
  [03:06:42.054]     }
  [03:06:42.054]     if (base::is.na(TRUE)) {
  [03:06:42.054]     }
  [03:06:42.054]     else {
  [03:06:42.054]         if (TRUE) {
  [03:06:42.054]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:06:42.054]                 open = "w")
  [03:06:42.054]         }
  [03:06:42.054]         else {
  [03:06:42.054]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:06:42.054]                 windows = "NUL", "/dev/null"), open = "w")
  [03:06:42.054]         }
  [03:06:42.054]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:06:42.054]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:06:42.054]             base::sink(type = "output", split = FALSE)
  [03:06:42.054]             base::close(...future.stdout)
  [03:06:42.054]         }, add = TRUE)
  [03:06:42.054]     }
  [03:06:42.054]     ...future.frame <- base::sys.nframe()
  [03:06:42.054]     ...future.conditions <- base::list()
  [03:06:42.054]     ...future.rng <- base::globalenv()$.Random.seed
  [03:06:42.054]     ...future.result <- base::tryCatch({
  [03:06:42.054]         base::withCallingHandlers({
  [03:06:42.054]             ...future.value <- base::withVisible(base::local({
  [03:06:42.054]                 2 * a
  [03:06:42.054]             }))
  [03:06:42.054]             future::FutureResult(value = ...future.value$value, 
  [03:06:42.054]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:42.054]                   ...future.rng), started = ...future.startTime, 
  [03:06:42.054]                 version = "1.8")
  [03:06:42.054]         }, condition = base::local({
  [03:06:42.054]             c <- base::c
  [03:06:42.054]             inherits <- base::inherits
  [03:06:42.054]             invokeRestart <- base::invokeRestart
  [03:06:42.054]             length <- base::length
  [03:06:42.054]             list <- base::list
  [03:06:42.054]             seq.int <- base::seq.int
  [03:06:42.054]             signalCondition <- base::signalCondition
  [03:06:42.054]             sys.calls <- base::sys.calls
  [03:06:42.054]             Sys.time <- base::Sys.time
  [03:06:42.054]             `[[` <- base::`[[`
  [03:06:42.054]             `+` <- base::`+`
  [03:06:42.054]             `<<-` <- base::`<<-`
  [03:06:42.054]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:06:42.054]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:06:42.054]                   3L)]
  [03:06:42.054]             }
  [03:06:42.054]             function(cond) {
  [03:06:42.054]                 if (inherits(cond, "error")) {
  [03:06:42.054]                   sessionInformation <- function() {
  [03:06:42.054]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:06:42.054]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:06:42.054]                       search = base::search(), system = base::Sys.info())
  [03:06:42.054]                   }
  [03:06:42.054]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:42.054]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:06:42.054]                     cond$call), session = sessionInformation(), 
  [03:06:42.054]                     timestamp = Sys.time(), signaled = 0L)
  [03:06:42.054]                   signalCondition(cond)
  [03:06:42.054]                 }
  [03:06:42.054]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:06:42.054]                 ))) {
  [03:06:42.054]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:06:42.054]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:42.054]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:06:42.054]                   if (!signal) {
  [03:06:42.054]                     muffleCondition <- function (cond) 
  [03:06:42.054]                     {
  [03:06:42.054]                       inherits <- base::inherits
  [03:06:42.054]                       invokeRestart <- base::invokeRestart
  [03:06:42.054]                       muffled <- FALSE
  [03:06:42.054]                       if (inherits(cond, "message")) {
  [03:06:42.054]                         invokeRestart("muffleMessage")
  [03:06:42.054]                         muffled <- TRUE
  [03:06:42.054]                       }
  [03:06:42.054]                       else if (inherits(cond, "warning")) {
  [03:06:42.054]                         invokeRestart("muffleWarning")
  [03:06:42.054]                         muffled <- TRUE
  [03:06:42.054]                       }
  [03:06:42.054]                       else if (inherits(cond, "condition")) {
  [03:06:42.054]                         computeRestarts <- base::computeRestarts
  [03:06:42.054]                         grepl <- base::grepl
  [03:06:42.054]                         is.null <- base::is.null
  [03:06:42.054]                         restarts <- computeRestarts(cond)
  [03:06:42.054]                         for (restart in restarts) {
  [03:06:42.054]                           name <- restart$name
  [03:06:42.054]                           if (is.null(name)) 
  [03:06:42.054]                             next
  [03:06:42.054]                           if (!grepl("^muffle", name)) 
  [03:06:42.054]                             next
  [03:06:42.054]                           invokeRestart(restart)
  [03:06:42.054]                           muffled <- TRUE
  [03:06:42.054]                           break
  [03:06:42.054]                         }
  [03:06:42.054]                       }
  [03:06:42.054]                       invisible(muffled)
  [03:06:42.054]                     }
  [03:06:42.054]                     muffleCondition(cond)
  [03:06:42.054]                   }
  [03:06:42.054]                 }
  [03:06:42.054]             }
  [03:06:42.054]         }))
  [03:06:42.054]     }, error = function(ex) {
  [03:06:42.054]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:06:42.054]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:42.054]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:06:42.054]     }, finally = {
  [03:06:42.054]         {
  [03:06:42.054]             NULL
  [03:06:42.054]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:06:42.054]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:06:42.054]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:06:42.054]                 label = NULL, ...) 
  [03:06:42.054]             {
  [03:06:42.054]                 if (substitute) 
  [03:06:42.054]                   expr <- substitute(expr)
  [03:06:42.054]                 local <- as.logical(local)
  [03:06:42.054]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:06:42.054]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:06:42.054]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:06:42.054]                   label = label, ...)
  [03:06:42.054]                 if (!future$lazy) 
  [03:06:42.054]                   future <- run(future)
  [03:06:42.054]                 invisible(future)
  [03:06:42.054]             }), .cleanup = FALSE, .init = FALSE)
  [03:06:42.054]         }
  [03:06:42.054]         base::options(...future.oldOptions)
  [03:06:42.054]     })
  [03:06:42.054]     Sys.time
  [03:06:42.054]     if (base::is.na(TRUE)) {
  [03:06:42.054]     }
  [03:06:42.054]     else {
  [03:06:42.054]         base::sink(type = "output", split = FALSE)
  [03:06:42.054]         if (TRUE) {
  [03:06:42.054]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:06:42.054]         }
  [03:06:42.054]         else {
  [03:06:42.054]             ...future.result["stdout"] <- base::list(NULL)
  [03:06:42.054]         }
  [03:06:42.054]         base::close(...future.stdout)
  [03:06:42.054]         ...future.stdout <- NULL
  [03:06:42.054]     }
  [03:06:42.054]     ...future.result$conditions <- ...future.conditions
  [03:06:42.054]     ...future.result
  [03:06:42.054] }
  [03:06:42.069] plan(): Setting new future strategy stack:
  [03:06:42.070] List of future strategies:
  [03:06:42.070] 1. sequential:
  [03:06:42.070]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:42.070]    - tweaked: FALSE
  [03:06:42.070]    - call: NULL
  [03:06:42.071] plan(): nbrOfWorkers() = 1
  [03:06:42.077] plan(): Setting new future strategy stack:
  [03:06:42.078] List of future strategies:
  [03:06:42.078] 1. sequential:
  [03:06:42.078]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:42.078]    - tweaked: FALSE
  [03:06:42.078]    - call: plan(strategy)
  [03:06:42.079] plan(): nbrOfWorkers() = 1
  [03:06:42.080] SequentialFuture started (and completed)
  [03:06:42.085] getGlobalsAndPackages() ...
  [03:06:42.086] Searching for globals...
  [03:06:42.093] - globals found: [3] '{', '*', 'a'
  [03:06:42.093] Searching for globals ... DONE
  [03:06:42.094] Resolving globals: FALSE
  [03:06:42.095] The total size of the 1 globals is 56 bytes (56 bytes)
  [03:06:42.096] - globals: [1] 'a'
  [03:06:42.096] 
  [03:06:42.101] getGlobalsAndPackages() ... DONE
  [03:06:42.104] Packages needed by the future expression (n = 0): <none>
  [03:06:42.104] Packages needed by future strategies (n = 0): <none>
  [03:06:42.121] {
  [03:06:42.121]     {
  [03:06:42.121]         ...future.startTime <- base::Sys.time()
  [03:06:42.121]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:06:42.121]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:06:42.121]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:06:42.121]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:06:42.121]             future.resolve.recursive = NULL, width = 80L)
  [03:06:42.121]         {
  [03:06:42.121]             {
  [03:06:42.121]                 base::local({
  [03:06:42.121]                   has_future <- base::requireNamespace("future", 
  [03:06:42.121]                     quietly = TRUE)
  [03:06:42.121]                   version <- if (has_future) 
  [03:06:42.121]                     utils::packageVersion("future")
  [03:06:42.121]                   else NULL
  [03:06:42.121]                   if (!has_future || version < "1.8.0") {
  [03:06:42.121]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:06:42.121]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:06:42.121]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:06:42.121]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:06:42.121]                         "release", "version")], collapse = " "), 
  [03:06:42.121]                       hostname = base::Sys.info()[["nodename"]])
  [03:06:42.121]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:06:42.121]                       info)
  [03:06:42.121]                     info <- base::paste(info, collapse = "; ")
  [03:06:42.121]                     if (!has_future) {
  [03:06:42.121]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:06:42.121]                         info)
  [03:06:42.121]                     }
  [03:06:42.121]                     else {
  [03:06:42.121]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:06:42.121]                         info, version)
  [03:06:42.121]                     }
  [03:06:42.121]                     base::stop(msg)
  [03:06:42.121]                   }
  [03:06:42.121]                 })
  [03:06:42.121]             }
  [03:06:42.121]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:06:42.121]         }
  [03:06:42.121]     }
  [03:06:42.121]     if (base::is.na(TRUE)) {
  [03:06:42.121]     }
  [03:06:42.121]     else {
  [03:06:42.121]         if (TRUE) {
  [03:06:42.121]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:06:42.121]                 open = "w")
  [03:06:42.121]         }
  [03:06:42.121]         else {
  [03:06:42.121]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:06:42.121]                 windows = "NUL", "/dev/null"), open = "w")
  [03:06:42.121]         }
  [03:06:42.121]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:06:42.121]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:06:42.121]             base::sink(type = "output", split = FALSE)
  [03:06:42.121]             base::close(...future.stdout)
  [03:06:42.121]         }, add = TRUE)
  [03:06:42.121]     }
  [03:06:42.121]     ...future.frame <- base::sys.nframe()
  [03:06:42.121]     ...future.conditions <- base::list()
  [03:06:42.121]     ...future.rng <- base::globalenv()$.Random.seed
  [03:06:42.121]     ...future.result <- base::tryCatch({
  [03:06:42.121]         base::withCallingHandlers({
  [03:06:42.121]             ...future.value <- base::withVisible(base::local({
  [03:06:42.121]                 2 * a
  [03:06:42.121]             }))
  [03:06:42.121]             future::FutureResult(value = ...future.value$value, 
  [03:06:42.121]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:42.121]                   ...future.rng), started = ...future.startTime, 
  [03:06:42.121]                 version = "1.8")
  [03:06:42.121]         }, condition = base::local({
  [03:06:42.121]             c <- base::c
  [03:06:42.121]             inherits <- base::inherits
  [03:06:42.121]             invokeRestart <- base::invokeRestart
  [03:06:42.121]             length <- base::length
  [03:06:42.121]             list <- base::list
  [03:06:42.121]             seq.int <- base::seq.int
  [03:06:42.121]             signalCondition <- base::signalCondition
  [03:06:42.121]             sys.calls <- base::sys.calls
  [03:06:42.121]             Sys.time <- base::Sys.time
  [03:06:42.121]             `[[` <- base::`[[`
  [03:06:42.121]             `+` <- base::`+`
  [03:06:42.121]             `<<-` <- base::`<<-`
  [03:06:42.121]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:06:42.121]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:06:42.121]                   3L)]
  [03:06:42.121]             }
  [03:06:42.121]             function(cond) {
  [03:06:42.121]                 if (inherits(cond, "error")) {
  [03:06:42.121]                   sessionInformation <- function() {
  [03:06:42.121]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:06:42.121]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:06:42.121]                       search = base::search(), system = base::Sys.info())
  [03:06:42.121]                   }
  [03:06:42.121]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:42.121]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:06:42.121]                     cond$call), session = sessionInformation(), 
  [03:06:42.121]                     timestamp = Sys.time(), signaled = 0L)
  [03:06:42.121]                   signalCondition(cond)
  [03:06:42.121]                 }
  [03:06:42.121]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:06:42.121]                 ))) {
  [03:06:42.121]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:06:42.121]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:42.121]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:06:42.121]                   if (!signal) {
  [03:06:42.121]                     muffleCondition <- function (cond) 
  [03:06:42.121]                     {
  [03:06:42.121]                       inherits <- base::inherits
  [03:06:42.121]                       invokeRestart <- base::invokeRestart
  [03:06:42.121]                       muffled <- FALSE
  [03:06:42.121]                       if (inherits(cond, "message")) {
  [03:06:42.121]                         invokeRestart("muffleMessage")
  [03:06:42.121]                         muffled <- TRUE
  [03:06:42.121]                       }
  [03:06:42.121]                       else if (inherits(cond, "warning")) {
  [03:06:42.121]                         invokeRestart("muffleWarning")
  [03:06:42.121]                         muffled <- TRUE
  [03:06:42.121]                       }
  [03:06:42.121]                       else if (inherits(cond, "condition")) {
  [03:06:42.121]                         computeRestarts <- base::computeRestarts
  [03:06:42.121]                         grepl <- base::grepl
  [03:06:42.121]                         is.null <- base::is.null
  [03:06:42.121]                         restarts <- computeRestarts(cond)
  [03:06:42.121]                         for (restart in restarts) {
  [03:06:42.121]                           name <- restart$name
  [03:06:42.121]                           if (is.null(name)) 
  [03:06:42.121]                             next
  [03:06:42.121]                           if (!grepl("^muffle", name)) 
  [03:06:42.121]                             next
  [03:06:42.121]                           invokeRestart(restart)
  [03:06:42.121]                           muffled <- TRUE
  [03:06:42.121]                           break
  [03:06:42.121]                         }
  [03:06:42.121]                       }
  [03:06:42.121]                       invisible(muffled)
  [03:06:42.121]                     }
  [03:06:42.121]                     muffleCondition(cond)
  [03:06:42.121]                   }
  [03:06:42.121]                 }
  [03:06:42.121]             }
  [03:06:42.121]         }))
  [03:06:42.121]     }, error = function(ex) {
  [03:06:42.121]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:06:42.121]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:42.121]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:06:42.121]     }, finally = {
  [03:06:42.121]         {
  [03:06:42.121]             NULL
  [03:06:42.121]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:06:42.121]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:06:42.121]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:06:42.121]                 label = NULL, ...) 
  [03:06:42.121]             {
  [03:06:42.121]                 if (substitute) 
  [03:06:42.121]                   expr <- substitute(expr)
  [03:06:42.121]                 local <- as.logical(local)
  [03:06:42.121]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:06:42.121]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:06:42.121]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:06:42.121]                   label = label, ...)
  [03:06:42.121]                 if (!future$lazy) 
  [03:06:42.121]                   future <- run(future)
  [03:06:42.121]                 invisible(future)
  [03:06:42.121]             }), .cleanup = FALSE, .init = FALSE)
  [03:06:42.121]         }
  [03:06:42.121]         base::options(...future.oldOptions)
  [03:06:42.121]     })
  [03:06:42.121]     Sys.time
  [03:06:42.121]     if (base::is.na(TRUE)) {
  [03:06:42.121]     }
  [03:06:42.121]     else {
  [03:06:42.121]         base::sink(type = "output", split = FALSE)
  [03:06:42.121]         if (TRUE) {
  [03:06:42.121]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:06:42.121]         }
  [03:06:42.121]         else {
  [03:06:42.121]             ...future.result["stdout"] <- base::list(NULL)
  [03:06:42.121]         }
  [03:06:42.121]         base::close(...future.stdout)
  [03:06:42.121]         ...future.stdout <- NULL
  [03:06:42.121]     }
  [03:06:42.121]     ...future.result$conditions <- ...future.conditions
  [03:06:42.121]     ...future.result
  [03:06:42.121] }
  [03:06:42.138] plan(): Setting new future strategy stack:
  [03:06:42.139] List of future strategies:
  [03:06:42.139] 1. sequential:
  [03:06:42.139]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:42.139]    - tweaked: FALSE
  [03:06:42.139]    - call: NULL
  [03:06:42.145] plan(): nbrOfWorkers() = 1
  [03:06:42.147] plan(): Setting new future strategy stack:
  [03:06:42.147] List of future strategies:
  [03:06:42.147] 1. sequential:
  [03:06:42.147]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:42.147]    - tweaked: FALSE
  [03:06:42.147]    - call: plan(strategy)
  [03:06:42.154] plan(): nbrOfWorkers() = 1
  [03:06:42.155] SequentialFuture started (and completed)
  [03:06:42.156] getGlobalsAndPackages() ...
  [03:06:42.157] Searching for globals...
  [03:06:42.164] - globals found: [3] '{', '*', 'a'
  [03:06:42.165] Searching for globals ... DONE
  [03:06:42.165] Resolving globals: FALSE
  [03:06:42.172] The total size of the 1 globals is 56 bytes (56 bytes)
  [03:06:42.177] - globals: [1] 'a'
  [03:06:42.177] 
  [03:06:42.178] getGlobalsAndPackages() ... DONE
  [03:06:42.184] Packages needed by the future expression (n = 0): <none>
  [03:06:42.185] Packages needed by future strategies (n = 0): <none>
  [03:06:42.201] {
  [03:06:42.201]     {
  [03:06:42.201]         ...future.startTime <- base::Sys.time()
  [03:06:42.201]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:06:42.201]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:06:42.201]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:06:42.201]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:06:42.201]             future.resolve.recursive = NULL, width = 80L)
  [03:06:42.201]         {
  [03:06:42.201]             {
  [03:06:42.201]                 base::local({
  [03:06:42.201]                   has_future <- base::requireNamespace("future", 
  [03:06:42.201]                     quietly = TRUE)
  [03:06:42.201]                   version <- if (has_future) 
  [03:06:42.201]                     utils::packageVersion("future")
  [03:06:42.201]                   else NULL
  [03:06:42.201]                   if (!has_future || version < "1.8.0") {
  [03:06:42.201]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:06:42.201]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:06:42.201]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:06:42.201]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:06:42.201]                         "release", "version")], collapse = " "), 
  [03:06:42.201]                       hostname = base::Sys.info()[["nodename"]])
  [03:06:42.201]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:06:42.201]                       info)
  [03:06:42.201]                     info <- base::paste(info, collapse = "; ")
  [03:06:42.201]                     if (!has_future) {
  [03:06:42.201]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:06:42.201]                         info)
  [03:06:42.201]                     }
  [03:06:42.201]                     else {
  [03:06:42.201]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:06:42.201]                         info, version)
  [03:06:42.201]                     }
  [03:06:42.201]                     base::stop(msg)
  [03:06:42.201]                   }
  [03:06:42.201]                 })
  [03:06:42.201]             }
  [03:06:42.201]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:06:42.201]         }
  [03:06:42.201]     }
  [03:06:42.201]     if (base::is.na(TRUE)) {
  [03:06:42.201]     }
  [03:06:42.201]     else {
  [03:06:42.201]         if (TRUE) {
  [03:06:42.201]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:06:42.201]                 open = "w")
  [03:06:42.201]         }
  [03:06:42.201]         else {
  [03:06:42.201]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:06:42.201]                 windows = "NUL", "/dev/null"), open = "w")
  [03:06:42.201]         }
  [03:06:42.201]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:06:42.201]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:06:42.201]             base::sink(type = "output", split = FALSE)
  [03:06:42.201]             base::close(...future.stdout)
  [03:06:42.201]         }, add = TRUE)
  [03:06:42.201]     }
  [03:06:42.201]     ...future.frame <- base::sys.nframe()
  [03:06:42.201]     ...future.conditions <- base::list()
  [03:06:42.201]     ...future.rng <- base::globalenv()$.Random.seed
  [03:06:42.201]     ...future.result <- base::tryCatch({
  [03:06:42.201]         base::withCallingHandlers({
  [03:06:42.201]             ...future.value <- base::withVisible(base::local({
  [03:06:42.201]                 2 * a
  [03:06:42.201]             }))
  [03:06:42.201]             future::FutureResult(value = ...future.value$value, 
  [03:06:42.201]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:42.201]                   ...future.rng), started = ...future.startTime, 
  [03:06:42.201]                 version = "1.8")
  [03:06:42.201]         }, condition = base::local({
  [03:06:42.201]             c <- base::c
  [03:06:42.201]             inherits <- base::inherits
  [03:06:42.201]             invokeRestart <- base::invokeRestart
  [03:06:42.201]             length <- base::length
  [03:06:42.201]             list <- base::list
  [03:06:42.201]             seq.int <- base::seq.int
  [03:06:42.201]             signalCondition <- base::signalCondition
  [03:06:42.201]             sys.calls <- base::sys.calls
  [03:06:42.201]             Sys.time <- base::Sys.time
  [03:06:42.201]             `[[` <- base::`[[`
  [03:06:42.201]             `+` <- base::`+`
  [03:06:42.201]             `<<-` <- base::`<<-`
  [03:06:42.201]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:06:42.201]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:06:42.201]                   3L)]
  [03:06:42.201]             }
  [03:06:42.201]             function(cond) {
  [03:06:42.201]                 if (inherits(cond, "error")) {
  [03:06:42.201]                   sessionInformation <- function() {
  [03:06:42.201]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:06:42.201]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:06:42.201]                       search = base::search(), system = base::Sys.info())
  [03:06:42.201]                   }
  [03:06:42.201]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:42.201]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:06:42.201]                     cond$call), session = sessionInformation(), 
  [03:06:42.201]                     timestamp = Sys.time(), signaled = 0L)
  [03:06:42.201]                   signalCondition(cond)
  [03:06:42.201]                 }
  [03:06:42.201]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:06:42.201]                 ))) {
  [03:06:42.201]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:06:42.201]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:42.201]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:06:42.201]                   if (!signal) {
  [03:06:42.201]                     muffleCondition <- function (cond) 
  [03:06:42.201]                     {
  [03:06:42.201]                       inherits <- base::inherits
  [03:06:42.201]                       invokeRestart <- base::invokeRestart
  [03:06:42.201]                       muffled <- FALSE
  [03:06:42.201]                       if (inherits(cond, "message")) {
  [03:06:42.201]                         invokeRestart("muffleMessage")
  [03:06:42.201]                         muffled <- TRUE
  [03:06:42.201]                       }
  [03:06:42.201]                       else if (inherits(cond, "warning")) {
  [03:06:42.201]                         invokeRestart("muffleWarning")
  [03:06:42.201]                         muffled <- TRUE
  [03:06:42.201]                       }
  [03:06:42.201]                       else if (inherits(cond, "condition")) {
  [03:06:42.201]                         computeRestarts <- base::computeRestarts
  [03:06:42.201]                         grepl <- base::grepl
  [03:06:42.201]                         is.null <- base::is.null
  [03:06:42.201]                         restarts <- computeRestarts(cond)
  [03:06:42.201]                         for (restart in restarts) {
  [03:06:42.201]                           name <- restart$name
  [03:06:42.201]                           if (is.null(name)) 
  [03:06:42.201]                             next
  [03:06:42.201]                           if (!grepl("^muffle", name)) 
  [03:06:42.201]                             next
  [03:06:42.201]                           invokeRestart(restart)
  [03:06:42.201]                           muffled <- TRUE
  [03:06:42.201]                           break
  [03:06:42.201]                         }
  [03:06:42.201]                       }
  [03:06:42.201]                       invisible(muffled)
  [03:06:42.201]                     }
  [03:06:42.201]                     muffleCondition(cond)
  [03:06:42.201]                   }
  [03:06:42.201]                 }
  [03:06:42.201]             }
  [03:06:42.201]         }))
  [03:06:42.201]     }, error = function(ex) {
  [03:06:42.201]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:06:42.201]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:42.201]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:06:42.201]     }, finally = {
  [03:06:42.201]         {
  [03:06:42.201]             NULL
  [03:06:42.201]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:06:42.201]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:06:42.201]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:06:42.201]                 label = NULL, ...) 
  [03:06:42.201]             {
  [03:06:42.201]                 if (substitute) 
  [03:06:42.201]                   expr <- substitute(expr)
  [03:06:42.201]                 local <- as.logical(local)
  [03:06:42.201]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:06:42.201]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:06:42.201]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:06:42.201]                   label = label, ...)
  [03:06:42.201]                 if (!future$lazy) 
  [03:06:42.201]                   future <- run(future)
  [03:06:42.201]                 invisible(future)
  [03:06:42.201]             }), .cleanup = FALSE, .init = FALSE)
  [03:06:42.201]         }
  [03:06:42.201]         base::options(...future.oldOptions)
  [03:06:42.201]     })
  [03:06:42.201]     Sys.time
  [03:06:42.201]     if (base::is.na(TRUE)) {
  [03:06:42.201]     }
  [03:06:42.201]     else {
  [03:06:42.201]         base::sink(type = "output", split = FALSE)
  [03:06:42.201]         if (TRUE) {
  [03:06:42.201]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:06:42.201]         }
  [03:06:42.201]         else {
  [03:06:42.201]             ...future.result["stdout"] <- base::list(NULL)
  [03:06:42.201]         }
  [03:06:42.201]         base::close(...future.stdout)
  [03:06:42.201]         ...future.stdout <- NULL
  [03:06:42.201]     }
  [03:06:42.201]     ...future.result$conditions <- ...future.conditions
  [03:06:42.201]     ...future.result
  [03:06:42.201] }
  [03:06:42.213] plan(): Setting new future strategy stack:
  [03:06:42.226] List of future strategies:
  [03:06:42.226] 1. sequential:
  [03:06:42.226]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:42.226]    - tweaked: FALSE
  [03:06:42.226]    - call: NULL
  [03:06:42.229] plan(): nbrOfWorkers() = 1
  [03:06:42.231] plan(): Setting new future strategy stack:
  [03:06:42.231] List of future strategies:
  [03:06:42.231] 1. sequential:
  [03:06:42.231]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:42.231]    - tweaked: FALSE
  [03:06:42.231]    - call: plan(strategy)
  [03:06:42.247] plan(): nbrOfWorkers() = 1
  [03:06:42.248] SequentialFuture started (and completed)
  [03:06:42.249] getGlobalsAndPackages() ...
  [03:06:42.249] Searching for globals...
  [03:06:42.252] - globals found: [3] '{', '*', 'a'
  [03:06:42.275] Searching for globals ... DONE
  [03:06:42.276] Resolving globals: FALSE
  [03:06:42.277] The total size of the 1 globals is 56 bytes (56 bytes)
  [03:06:42.278] - globals: [1] 'a'
  [03:06:42.278] 
  [03:06:42.279] getGlobalsAndPackages() ... DONE
  [03:06:42.296] Packages needed by the future expression (n = 0): <none>
  [03:06:42.296] Packages needed by future strategies (n = 0): <none>
  [03:06:42.318] {
  [03:06:42.318]     {
  [03:06:42.318]         ...future.startTime <- base::Sys.time()
  [03:06:42.318]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:06:42.318]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:06:42.318]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:06:42.318]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:06:42.318]             future.resolve.recursive = NULL, width = 80L)
  [03:06:42.318]         {
  [03:06:42.318]             {
  [03:06:42.318]                 base::local({
  [03:06:42.318]                   has_future <- base::requireNamespace("future", 
  [03:06:42.318]                     quietly = TRUE)
  [03:06:42.318]                   version <- if (has_future) 
  [03:06:42.318]                     utils::packageVersion("future")
  [03:06:42.318]                   else NULL
  [03:06:42.318]                   if (!has_future || version < "1.8.0") {
  [03:06:42.318]                     info <- base::c(r_version = base::gsub("R version ", 
  [03:06:42.318]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [03:06:42.318]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:06:42.318]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:06:42.318]                         "release", "version")], collapse = " "), 
  [03:06:42.318]                       hostname = base::Sys.info()[["nodename"]])
  [03:06:42.318]                     info <- base::sprintf("%s: %s", base::names(info), 
  [03:06:42.318]                       info)
  [03:06:42.318]                     info <- base::paste(info, collapse = "; ")
  [03:06:42.318]                     if (!has_future) {
  [03:06:42.318]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:06:42.318]                         info)
  [03:06:42.318]                     }
  [03:06:42.318]                     else {
  [03:06:42.318]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:06:42.318]                         info, version)
  [03:06:42.318]                     }
  [03:06:42.318]                     base::stop(msg)
  [03:06:42.318]                   }
  [03:06:42.318]                 })
  [03:06:42.318]             }
  [03:06:42.318]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:06:42.318]         }
  [03:06:42.318]     }
  [03:06:42.318]     if (base::is.na(TRUE)) {
  [03:06:42.318]     }
  [03:06:42.318]     else {
  [03:06:42.318]         if (TRUE) {
  [03:06:42.318]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:06:42.318]                 open = "w")
  [03:06:42.318]         }
  [03:06:42.318]         else {
  [03:06:42.318]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:06:42.318]                 windows = "NUL", "/dev/null"), open = "w")
  [03:06:42.318]         }
  [03:06:42.318]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:06:42.318]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:06:42.318]             base::sink(type = "output", split = FALSE)
  [03:06:42.318]             base::close(...future.stdout)
  [03:06:42.318]         }, add = TRUE)
  [03:06:42.318]     }
  [03:06:42.318]     ...future.frame <- base::sys.nframe()
  [03:06:42.318]     ...future.conditions <- base::list()
  [03:06:42.318]     ...future.rng <- base::globalenv()$.Random.seed
  [03:06:42.318]     ...future.result <- base::tryCatch({
  [03:06:42.318]         base::withCallingHandlers({
  [03:06:42.318]             ...future.value <- base::withVisible(base::local({
  [03:06:42.318]                 2 * a
  [03:06:42.318]             }))
  [03:06:42.318]             future::FutureResult(value = ...future.value$value, 
  [03:06:42.318]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:42.318]                   ...future.rng), started = ...future.startTime, 
  [03:06:42.318]                 version = "1.8")
  [03:06:42.318]         }, condition = base::local({
  [03:06:42.318]             c <- base::c
  [03:06:42.318]             inherits <- base::inherits
  [03:06:42.318]             invokeRestart <- base::invokeRestart
  [03:06:42.318]             length <- base::length
  [03:06:42.318]             list <- base::list
  [03:06:42.318]             seq.int <- base::seq.int
  [03:06:42.318]             signalCondition <- base::signalCondition
  [03:06:42.318]             sys.calls <- base::sys.calls
  [03:06:42.318]             Sys.time <- base::Sys.time
  [03:06:42.318]             `[[` <- base::`[[`
  [03:06:42.318]             `+` <- base::`+`
  [03:06:42.318]             `<<-` <- base::`<<-`
  [03:06:42.318]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:06:42.318]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:06:42.318]                   3L)]
  [03:06:42.318]             }
  [03:06:42.318]             function(cond) {
  [03:06:42.318]                 if (inherits(cond, "error")) {
  [03:06:42.318]                   sessionInformation <- function() {
  [03:06:42.318]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:06:42.318]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:06:42.318]                       search = base::search(), system = base::Sys.info())
  [03:06:42.318]                   }
  [03:06:42.318]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:42.318]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:06:42.318]                     cond$call), session = sessionInformation(), 
  [03:06:42.318]                     timestamp = Sys.time(), signaled = 0L)
  [03:06:42.318]                   signalCondition(cond)
  [03:06:42.318]                 }
  [03:06:42.318]                 else if (inherits(cond, c("condition", "immediateCondition"
  [03:06:42.318]                 ))) {
  [03:06:42.318]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [03:06:42.318]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:42.318]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:06:42.318]                   if (!signal) {
  [03:06:42.318]                     muffleCondition <- function (cond) 
  [03:06:42.318]                     {
  [03:06:42.318]                       inherits <- base::inherits
  [03:06:42.318]                       invokeRestart <- base::invokeRestart
  [03:06:42.318]                       muffled <- FALSE
  [03:06:42.318]                       if (inherits(cond, "message")) {
  [03:06:42.318]                         invokeRestart("muffleMessage")
  [03:06:42.318]                         muffled <- TRUE
  [03:06:42.318]                       }
  [03:06:42.318]                       else if (inherits(cond, "warning")) {
  [03:06:42.318]                         invokeRestart("muffleWarning")
  [03:06:42.318]                         muffled <- TRUE
  [03:06:42.318]                       }
  [03:06:42.318]                       else if (inherits(cond, "condition")) {
  [03:06:42.318]                         computeRestarts <- base::computeRestarts
  [03:06:42.318]                         grepl <- base::grepl
  [03:06:42.318]                         is.null <- base::is.null
  [03:06:42.318]                         restarts <- computeRestarts(cond)
  [03:06:42.318]                         for (restart in restarts) {
  [03:06:42.318]                           name <- restart$name
  [03:06:42.318]                           if (is.null(name)) 
  [03:06:42.318]                             next
  [03:06:42.318]                           if (!grepl("^muffle", name)) 
  [03:06:42.318]                             next
  [03:06:42.318]                           invokeRestart(restart)
  [03:06:42.318]                           muffled <- TRUE
  [03:06:42.318]                           break
  [03:06:42.318]                         }
  [03:06:42.318]                       }
  [03:06:42.318]                       invisible(muffled)
  [03:06:42.318]                     }
  [03:06:42.318]                     muffleCondition(cond)
  [03:06:42.318]                   }
  [03:06:42.318]                 }
  [03:06:42.318]             }
  [03:06:42.318]         }))
  [03:06:42.318]     }, error = function(ex) {
  [03:06:42.318]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:06:42.318]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:42.318]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:06:42.318]     }, finally = {
  [03:06:42.318]         {
  [03:06:42.318]             NULL
  [03:06:42.318]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:06:42.318]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:06:42.318]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [03:06:42.318]                 label = NULL, ...) 
  [03:06:42.318]             {
  [03:06:42.318]                 if (substitute) 
  [03:06:42.318]                   expr <- substitute(expr)
  [03:06:42.318]                 local <- as.logical(local)
  [03:06:42.318]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [03:06:42.318]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:06:42.318]                   globals = globals, local = local, earlySignal = earlySignal, 
  [03:06:42.318]                   label = label, ...)
  [03:06:42.318]                 if (!future$lazy) 
  [03:06:42.318]                   future <- run(future)
  [03:06:42.318]                 invisible(future)
  [03:06:42.318]             }), .cleanup = FALSE, .init = FALSE)
  [03:06:42.318]         }
  [03:06:42.318]         base::options(...future.oldOptions)
  [03:06:42.318]     })
  [03:06:42.318]     Sys.time
  [03:06:42.318]     if (base::is.na(TRUE)) {
  [03:06:42.318]     }
  [03:06:42.318]     else {
  [03:06:42.318]         base::sink(type = "output", split = FALSE)
  [03:06:42.318]         if (TRUE) {
  [03:06:42.318]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:06:42.318]         }
  [03:06:42.318]         else {
  [03:06:42.318]             ...future.result["stdout"] <- base::list(NULL)
  [03:06:42.318]         }
  [03:06:42.318]         base::close(...future.stdout)
  [03:06:42.318]         ...future.stdout <- NULL
  [03:06:42.318]     }
  [03:06:42.318]     ...future.result$conditions <- ...future.conditions
  [03:06:42.318]     ...future.result
  [03:06:42.318] }
  [03:06:42.339] plan(): Setting new future strategy stack:
  [03:06:42.344] List of future strategies:
  [03:06:42.344] 1. sequential:
  [03:06:42.344]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:42.344]    - tweaked: FALSE
  [03:06:42.344]    - call: NULL
  [03:06:42.345] plan(): nbrOfWorkers() = 1
  [03:06:42.354] plan(): Setting new future strategy stack:
  [03:06:42.355] List of future strategies:
  [03:06:42.355] 1. sequential:
  [03:06:42.355]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [03:06:42.355]    - tweaked: FALSE
  [03:06:42.355]    - call: plan(strategy)
  [03:06:42.362] plan(): nbrOfWorkers() = 1
  [03:06:42.363] SequentialFuture started (and completed)
  *** futureAssign() with 'sequential' futures ... DONE
  Testing with 1 cores ... DONE
  Testing with 2 cores ...
  *** futureAssign() with 'multicore' futures ...
  [03:06:42.408] plan(): Setting new future strategy stack:
  [03:06:42.409] List of future strategies:
  [03:06:42.409] 1. multicore:
  [03:06:42.409]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [03:06:42.409]    - tweaked: FALSE
  [03:06:42.409]    - call: plan(strategy)
  [03:06:42.411] plan(): nbrOfWorkers() = 2
  [03:06:42.419] getGlobalsAndPackages() ...
  [03:06:42.420] Searching for globals...
  [03:06:42.421] - globals found: [1] '{'
  [03:06:42.422] Searching for globals ... DONE
  [03:06:42.422] Resolving globals: FALSE
  [03:06:42.428] 
  [03:06:42.429] 
  [03:06:42.429] getGlobalsAndPackages() ... DONE
  [03:06:42.438] Packages needed by the future expression (n = 0): <none>
  [03:06:42.439] Packages needed by future strategies (n = 0): <none>
  [03:06:42.457] {
  [03:06:42.457]     {
  [03:06:42.457]         ...future.startTime <- base::Sys.time()
  [03:06:42.457]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [03:06:42.457]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [03:06:42.457]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [03:06:42.457]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [03:06:42.457]             future.resolve.recursive = NULL, width = 80L)
  [03:06:42.457]         {
  [03:06:42.457]             {
  [03:06:42.457]                 {
  [03:06:42.457]                   base::local({
  [03:06:42.457]                     has_future <- base::requireNamespace("future", 
  [03:06:42.457]                       quietly = TRUE)
  [03:06:42.457]                     version <- if (has_future) 
  [03:06:42.457]                       utils::packageVersion("future")
  [03:06:42.457]                     else NULL
  [03:06:42.457]                     if (!has_future || version < "1.8.0") {
  [03:06:42.457]                       info <- base::c(r_version = base::gsub("R version ", 
  [03:06:42.457]                         "", base::R.version$version.string), 
  [03:06:42.457]                         platform = base::sprintf("%s (%s-bit)", 
  [03:06:42.457]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [03:06:42.457]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [03:06:42.457]                           "release", "version")], collapse = " "), 
  [03:06:42.457]                         hostname = base::Sys.info()[["nodename"]])
  [03:06:42.457]                       info <- base::sprintf("%s: %s", base::names(info), 
  [03:06:42.457]                         info)
  [03:06:42.457]                       info <- base::paste(info, collapse = "; ")
  [03:06:42.457]                       if (!has_future) {
  [03:06:42.457]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [03:06:42.457]                           info)
  [03:06:42.457]                       }
  [03:06:42.457]                       else {
  [03:06:42.457]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [03:06:42.457]                           info, version)
  [03:06:42.457]                       }
  [03:06:42.457]                       base::stop(msg)
  [03:06:42.457]                     }
  [03:06:42.457]                   })
  [03:06:42.457]                 }
  [03:06:42.457]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [03:06:42.457]                 base::options(mc.cores = 1L)
  [03:06:42.457]             }
  [03:06:42.457]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [03:06:42.457]         }
  [03:06:42.457]     }
  [03:06:42.457]     if (base::is.na(TRUE)) {
  [03:06:42.457]     }
  [03:06:42.457]     else {
  [03:06:42.457]         if (TRUE) {
  [03:06:42.457]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [03:06:42.457]                 open = "w")
  [03:06:42.457]         }
  [03:06:42.457]         else {
  [03:06:42.457]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [03:06:42.457]                 windows = "NUL", "/dev/null"), open = "w")
  [03:06:42.457]         }
  [03:06:42.457]         base::sink(...future.stdout, type = "output", split = FALSE)
  [03:06:42.457]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [03:06:42.457]             base::sink(type = "output", split = FALSE)
  [03:06:42.457]             base::close(...future.stdout)
  [03:06:42.457]         }, add = TRUE)
  [03:06:42.457]     }
  [03:06:42.457]     ...future.frame <- base::sys.nframe()
  [03:06:42.457]     ...future.conditions <- base::list()
  [03:06:42.457]     ...future.rng <- base::globalenv()$.Random.seed
  [03:06:42.457]     ...future.result <- base::tryCatch({
  [03:06:42.457]         base::withCallingHandlers({
  [03:06:42.457]             ...future.value <- base::withVisible(base::local({
  [03:06:42.457]                 2
  [03:06:42.457]             }))
  [03:06:42.457]             future::FutureResult(value = ...future.value$value, 
  [03:06:42.457]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:42.457]                   ...future.rng), started = ...future.startTime, 
  [03:06:42.457]                 version = "1.8")
  [03:06:42.457]         }, condition = base::local({
  [03:06:42.457]             c <- base::c
  [03:06:42.457]             inherits <- base::inherits
  [03:06:42.457]             invokeRestart <- base::invokeRestart
  [03:06:42.457]             length <- base::length
  [03:06:42.457]             list <- base::list
  [03:06:42.457]             seq.int <- base::seq.int
  [03:06:42.457]             signalCondition <- base::signalCondition
  [03:06:42.457]             sys.calls <- base::sys.calls
  [03:06:42.457]             Sys.time <- base::Sys.time
  [03:06:42.457]             `[[` <- base::`[[`
  [03:06:42.457]             `+` <- base::`+`
  [03:06:42.457]             `<<-` <- base::`<<-`
  [03:06:42.457]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [03:06:42.457]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [03:06:42.457]                   3L)]
  [03:06:42.457]             }
  [03:06:42.457]             function(cond) {
  [03:06:42.457]                 if (inherits(cond, "error")) {
  [03:06:42.457]                   sessionInformation <- function() {
  [03:06:42.457]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [03:06:42.457]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [03:06:42.457]                       search = base::search(), system = base::Sys.info())
  [03:06:42.457]                   }
  [03:06:42.457]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:42.457]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [03:06:42.457]                     cond$call), session = sessionInformation(), 
  [03:06:42.457]                     timestamp = Sys.time(), signaled = 0L)
  [03:06:42.457]                   signalCondition(cond)
  [03:06:42.457]                 }
  [03:06:42.457]                 else if (inherits(cond, "condition")) {
  [03:06:42.457]                   signal <- FALSE && inherits(cond, character(0))
  [03:06:42.457]                   ...future.conditions[[length(...future.conditions) + 
  [03:06:42.457]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [03:06:42.457]                   if (!signal) {
  [03:06:42.457]                     muffleCondition <- function (cond) 
  [03:06:42.457]                     {
  [03:06:42.457]                       inherits <- base::inherits
  [03:06:42.457]                       invokeRestart <- base::invokeRestart
  [03:06:42.457]                       muffled <- FALSE
  [03:06:42.457]                       if (inherits(cond, "message")) {
  [03:06:42.457]                         invokeRestart("muffleMessage")
  [03:06:42.457]                         muffled <- TRUE
  [03:06:42.457]                       }
  [03:06:42.457]                       else if (inherits(cond, "warning")) {
  [03:06:42.457]                         invokeRestart("muffleWarning")
  [03:06:42.457]                         muffled <- TRUE
  [03:06:42.457]                       }
  [03:06:42.457]                       else if (inherits(cond, "condition")) {
  [03:06:42.457]                         computeRestarts <- base::computeRestarts
  [03:06:42.457]                         grepl <- base::grepl
  [03:06:42.457]                         is.null <- base::is.null
  [03:06:42.457]                         restarts <- computeRestarts(cond)
  [03:06:42.457]                         for (restart in restarts) {
  [03:06:42.457]                           name <- restart$name
  [03:06:42.457]                           if (is.null(name)) 
  [03:06:42.457]                             next
  [03:06:42.457]                           if (!grepl("^muffle", name)) 
  [03:06:42.457]                             next
  [03:06:42.457]                           invokeRestart(restart)
  [03:06:42.457]                           muffled <- TRUE
  [03:06:42.457]                           break
  [03:06:42.457]                         }
  [03:06:42.457]                       }
  [03:06:42.457]                       invisible(muffled)
  [03:06:42.457]                     }
  [03:06:42.457]                     muffleCondition(cond)
  [03:06:42.457]                   }
  [03:06:42.457]                 }
  [03:06:42.457]             }
  [03:06:42.457]         }))
  [03:06:42.457]     }, error = function(ex) {
  [03:06:42.457]         base::structure(base::list(value = NULL, visible = NULL, 
  [03:06:42.457]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [03:06:42.457]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [03:06:42.457]     }, finally = {
  [03:06:42.457]         {
  [03:06:42.457]             {
  [03:06:42.457]                 base::options(mc.cores = ...future.mc.cores.old)
  [03:06:42.457]             }
  [03:06:42.457]             future::plan(list(function (expr, envir = parent.frame(), 
  [03:06:42.457]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [03:06:42.457]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [03:06:42.457]                 earlySignal = FALSE, label = NULL, ...) 
  [03:06:42.457]             {
  [03:06:42.457]                 if (substitute) 
  [03:06:42.457]                   expr <- substitute(expr)
  [03:06:42.457]                 if (is.function(workers)) 
  [03:06:42.457]                   workers <- workers()
  [03:06:42.457]                 workers <- as.integer(workers)
  [03:06:42.457]                 stop_if_not(is.finite(workers), workers >= 1L)
  [03:06:42.457]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [03:06:42.457]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [03:06:42.457]                     lazy = lazy, seed = seed, globals = globals, 
  [03:06:42.457]                     local = TRUE, label = label, ...))
  [03:06:42.457]                 }
  [03:06:42.457]                 oopts <- options(mc.cores = workers)
  [03:06:42.457]                 on.exit(options(oopts))
  [03:06:42.457]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [03:06:42.457]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [03:06:42.457]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [03:06:42.457]                   label = label, ...)
  [03:06:42.457]                 if (!future$lazy) 
  [03:06:42.457]                   future <- run(future)
  [03:06:42.457]                 invisible(future)
  [03:06:42.457]             }), .cleanup = FALSE, .init = FALSE)
  [03:06:42.457]         }
  [03:06:42.457]         base::options(...future.oldOptions)
  [03:06:42.457]     })
  [03:06:42.457]     Sys.time
  [03:06:42.457]     if (base::is.na(TRUE)) {
  [03:06:42.457]     }
  [03:06:42.457]     else {
  [03:06:42.457]         base::sink(type = "output", split = FALSE)
  [03:06:42.457]         if (TRUE) {
  [03:06:42.457]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [03:06:42.457]         }
  [03:06:42.457]         else {
  [03:06:42.457]             ...future.result["stdout"] <- base::list(NULL)
  [03:06:42.457]         }
  [03:06:42.457]         base::close(...future.stdout)
  [03:06:42.457]         ...future.stdout <- NULL
  [03:06:42.457]     }
  [03:06:42.457]     ...future.result$conditions <- ...future.conditions
  [03:06:42.457]     ...future.result
  [03:06:42.457] }
  [03:06:42.468] requestCore(): workers = 2
  [03:06:42.488] MulticoreFuture started
  [03:06:42.500] plan(): Setting new future strategy stack:
  [03:06:42.506] getGlobalsAndPackages() ...
  [03:06:42.507] Searching for globals...
  [03:06:42.505] List of future strategies:
  [03:06:42.505] 1. sequential:
  [03:06:42.505]    - args: function (expr, envir = parent.frame(