Running ‘000.sessionDetails.R’
  Running ‘ClusterRegistry.R’ [1s/121s]
  Running ‘Future-class.R’ [1s/121s]
  Running ‘FutureError.R’
  Running ‘FutureGlobals.R’
  Running ‘FutureRegistry.R’
  Running ‘as.cluster.R’ [1s/121s]
  Running ‘availableCores.R’
  Running ‘availableWorkers.R’
  Running ‘backtrace.R’
  Running ‘cluster-missing-future-pkg.R’
  Running ‘cluster.R’ [1s/122s]
  Running ‘constant.R’
  Running ‘demo.R’ [11s/132s]
  Running ‘dotdotdot.R’ [1s/122s]
  Running ‘early-signaling.R’ [1s/121s]
  Running ‘future,labels.R’
  Running ‘future.R’
  Running ‘futureAssign.R’ [1s/122s]
  Running ‘futureAssign_OP.R’ [2s/122s]
  Running ‘futureAssign_OP_with_environment.R’
  Running ‘futureAssign_OP_with_listenv.R’
  Running ‘futureCall.R’ [2s/122s]
  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")
  [06:58:49.946] plan(): Setting new future strategy stack:
  [06:58:49.948] List of future strategies:
  [06:58:49.948] 1. sequential:
  [06:58:49.948]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:58:49.948]    - tweaked: FALSE
  [06:58:49.948]    - call: future::plan("sequential")
  [06:58:49.949] 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: 29021
  [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/Rtmpk6JOTc/working_dir/Rtmp6pE2Ec/future.parent=649115.9e79b27f9d170.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmpk6JOTc/working_dir/Rtmp6pE2Ec/future.parent=649115.9e79b27f9d170.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:649115' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpk6JOTc/working_dir/Rtmp6pE2Ec/future.parent=649115.9e79b27f9d170.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=29021 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 649185) if still alive
  [07:00:50.794] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(649115, signal = 0L)
  [1] TRUE
  Call: tools::pskill(649115, signal = 0L)
  [1] TRUE
  [07:00:50.795] - success
  [07:00:50.795] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 649185) 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 29021 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:649115' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpk6JOTc/working_dir/Rtmp6pE2Ec/future.parent=649115.9e79b27f9d170.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=29021 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 649185) 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")
  [07:00:51.171] plan(): Setting new future strategy stack:
  [07:00:51.172] List of future strategies:
  [07:00:51.172] 1. sequential:
  [07:00:51.172]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:00:51.172]    - tweaked: FALSE
  [07:00:51.172]    - call: future::plan("sequential")
  [07:00:51.174] 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: 49a7ab64-0c49-2163-3451-b2e2608a20ef
  Class: 'Future', 'environment'
  > res <- tryCatch(value(f), error = identity)
  > print(res)
  <simpleError: C stack usage  19929812 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)
  [07:00:51.232] plan(): Setting new future strategy stack:
  [07:00:51.232] List of future strategies:
  [07:00:51.232] 1. future:
  [07:00:51.232]    - args: function (...)
  [07:00:51.232]    - tweaked: FALSE
  [07:00:51.232]    - call: plan(foo)
  [07:00:51.258] plan(): nbrOfWorkers() = Inf
  > f <- Future()
  > expr <- getExpression(f)
  [07:00:51.260] Packages needed by the future expression (n = 0): <none>
  [07:00:51.261] Packages needed by future strategies (n = 0): <none>
  [07:00:51.265] {
  [07:00:51.265]     {
  [07:00:51.265]         ...future.startTime <- base::Sys.time()
  [07:00:51.265]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:00:51.265]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:00:51.265]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:00:51.265]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:00:51.265]             future.resolve.recursive = NULL, width = 80L)
  [07:00:51.265]         {
  [07:00:51.265]             {
  [07:00:51.265]                 base::local({
  [07:00:51.265]                   has_future <- base::requireNamespace("future", 
  [07:00:51.265]                     quietly = TRUE)
  [07:00:51.265]                   version <- if (has_future) 
  [07:00:51.265]                     utils::packageVersion("future")
  [07:00:51.265]                   else NULL
  [07:00:51.265]                   if (!has_future || version < "1.8.0") {
  [07:00:51.265]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:00:51.265]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:00:51.265]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:00:51.265]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:00:51.265]                         "release", "version")], collapse = " "), 
  [07:00:51.265]                       hostname = base::Sys.info()[["nodename"]])
  [07:00:51.265]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:00:51.265]                       info)
  [07:00:51.265]                     info <- base::paste(info, collapse = "; ")
  [07:00:51.265]                     if (!has_future) {
  [07:00:51.265]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:00:51.265]                         info)
  [07:00:51.265]                     }
  [07:00:51.265]                     else {
  [07:00:51.265]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:00:51.265]                         info, version)
  [07:00:51.265]                     }
  [07:00:51.265]                     base::stop(msg)
  [07:00:51.265]                   }
  [07:00:51.265]                 })
  [07:00:51.265]             }
  [07:00:51.265]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:00:51.265]         }
  [07:00:51.265]     }
  [07:00:51.265]     if (base::is.na(TRUE)) {
  [07:00:51.265]     }
  [07:00:51.265]     else {
  [07:00:51.265]         if (TRUE) {
  [07:00:51.265]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:00:51.265]                 open = "w")
  [07:00:51.265]         }
  [07:00:51.265]         else {
  [07:00:51.265]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:00:51.265]                 windows = "NUL", "/dev/null"), open = "w")
  [07:00:51.265]         }
  [07:00:51.265]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:00:51.265]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:00:51.265]             base::sink(type = "output", split = FALSE)
  [07:00:51.265]             base::close(...future.stdout)
  [07:00:51.265]         }, add = TRUE)
  [07:00:51.265]     }
  [07:00:51.265]     ...future.frame <- base::sys.nframe()
  [07:00:51.265]     ...future.conditions <- base::list()
  [07:00:51.265]     ...future.rng <- base::globalenv()$.Random.seed
  [07:00:51.265]     ...future.result <- base::tryCatch({
  [07:00:51.265]         base::withCallingHandlers({
  [07:00:51.265]             ...future.value <- base::withVisible(base::local(NULL))
  [07:00:51.265]             future::FutureResult(value = ...future.value$value, 
  [07:00:51.265]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:00:51.265]                   ...future.rng), started = ...future.startTime, 
  [07:00:51.265]                 version = "1.8")
  [07:00:51.265]         }, condition = base::local({
  [07:00:51.265]             c <- base::c
  [07:00:51.265]             inherits <- base::inherits
  [07:00:51.265]             invokeRestart <- base::invokeRestart
  [07:00:51.265]             length <- base::length
  [07:00:51.265]             list <- base::list
  [07:00:51.265]             seq.int <- base::seq.int
  [07:00:51.265]             signalCondition <- base::signalCondition
  [07:00:51.265]             sys.calls <- base::sys.calls
  [07:00:51.265]             Sys.time <- base::Sys.time
  [07:00:51.265]             `[[` <- base::`[[`
  [07:00:51.265]             `+` <- base::`+`
  [07:00:51.265]             `<<-` <- base::`<<-`
  [07:00:51.265]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:00:51.265]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:00:51.265]                   3L)]
  [07:00:51.265]             }
  [07:00:51.265]             function(cond) {
  [07:00:51.265]                 if (inherits(cond, "error")) {
  [07:00:51.265]                   sessionInformation <- function() {
  [07:00:51.265]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:00:51.265]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:00:51.265]                       search = base::search(), system = base::Sys.info())
  [07:00:51.265]                   }
  [07:00:51.265]                   ...future.conditions[[length(...future.conditions) + 
  [07:00:51.265]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:00:51.265]                     cond$call), session = sessionInformation(), 
  [07:00:51.265]                     timestamp = Sys.time(), signaled = 0L)
  [07:00:51.265]                   signalCondition(cond)
  [07:00:51.265]                 }
  [07:00:51.265]                 else if (inherits(cond, "condition")) {
  [07:00:51.265]                   signal <- FALSE && inherits(cond, character(0))
  [07:00:51.265]                   ...future.conditions[[length(...future.conditions) + 
  [07:00:51.265]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:00:51.265]                   if (!signal) {
  [07:00:51.265]                     muffleCondition <- function (cond) 
  [07:00:51.265]                     {
  [07:00:51.265]                       inherits <- base::inherits
  [07:00:51.265]                       invokeRestart <- base::invokeRestart
  [07:00:51.265]                       muffled <- FALSE
  [07:00:51.265]                       if (inherits(cond, "message")) {
  [07:00:51.265]                         invokeRestart("muffleMessage")
  [07:00:51.265]                         muffled <- TRUE
  [07:00:51.265]                       }
  [07:00:51.265]                       else if (inherits(cond, "warning")) {
  [07:00:51.265]                         invokeRestart("muffleWarning")
  [07:00:51.265]                         muffled <- TRUE
  [07:00:51.265]                       }
  [07:00:51.265]                       else if (inherits(cond, "condition")) {
  [07:00:51.265]                         computeRestarts <- base::computeRestarts
  [07:00:51.265]                         grepl <- base::grepl
  [07:00:51.265]                         is.null <- base::is.null
  [07:00:51.265]                         restarts <- computeRestarts(cond)
  [07:00:51.265]                         for (restart in restarts) {
  [07:00:51.265]                           name <- restart$name
  [07:00:51.265]                           if (is.null(name)) 
  [07:00:51.265]                             next
  [07:00:51.265]                           if (!grepl("^muffle", name)) 
  [07:00:51.265]                             next
  [07:00:51.265]                           invokeRestart(restart)
  [07:00:51.265]                           muffled <- TRUE
  [07:00:51.265]                           break
  [07:00:51.265]                         }
  [07:00:51.265]                       }
  [07:00:51.265]                       invisible(muffled)
  [07:00:51.265]                     }
  [07:00:51.265]                     muffleCondition(cond)
  [07:00:51.265]                   }
  [07:00:51.265]                 }
  [07:00:51.265]             }
  [07:00:51.265]         }))
  [07:00:51.265]     }, error = function(ex) {
  [07:00:51.265]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:00:51.265]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:00:51.265]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:00:51.265]     }, finally = {
  [07:00:51.265]         {
  [07:00:51.265]             NULL
  [07:00:51.265]             future::plan(list(function (...) 
  [07:00:51.265]             {
  [07:00:51.265]                 Future(1)
  [07:00:51.265]             }), .cleanup = FALSE, .init = FALSE)
  [07:00:51.265]         }
  [07:00:51.265]         base::options(...future.oldOptions)
  [07:00:51.265]     })
  [07:00:51.265]     Sys.time
  [07:00:51.265]     if (base::is.na(TRUE)) {
  [07:00:51.265]     }
  [07:00:51.265]     else {
  [07:00:51.265]         base::sink(type = "output", split = FALSE)
  [07:00:51.265]         if (TRUE) {
  [07:00:51.265]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:00:51.265]         }
  [07:00:51.265]         else {
  [07:00:51.265]             ...future.result["stdout"] <- base::list(NULL)
  [07:00:51.265]         }
  [07:00:51.265]         base::close(...future.stdout)
  [07:00:51.265]         ...future.stdout <- NULL
  [07:00:51.265]     }
  [07:00:51.265]     ...future.result$conditions <- ...future.conditions
  [07:00:51.265]     ...future.result
  [07:00:51.265] }
  > 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)
  + }
  [07:00:51.285] getGlobalsAndPackages() ...
  [07:00:51.286] Searching for globals...
  [07:00:51.289] 
  [07:00:51.289] Searching for globals ... DONE
  [07:00:51.290] - globals: [0] <none>
  [07:00:51.290] 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: 49a7ab64-0c49-2163-3451-b2e2608a20ef
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [07:00:51.293] Packages needed by the future expression (n = 0): <none>
  [07:00:51.293] Packages needed by future strategies (n = 0): <none>
  [07:00:51.296] {
  [07:00:51.296]     {
  [07:00:51.296]         ...future.startTime <- base::Sys.time()
  [07:00:51.296]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:00:51.296]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:00:51.296]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:00:51.296]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:00:51.296]             future.resolve.recursive = NULL, width = 80L)
  [07:00:51.296]         {
  [07:00:51.296]             {
  [07:00:51.296]                 base::local({
  [07:00:51.296]                   has_future <- base::requireNamespace("future", 
  [07:00:51.296]                     quietly = TRUE)
  [07:00:51.296]                   version <- if (has_future) 
  [07:00:51.296]                     utils::packageVersion("future")
  [07:00:51.296]                   else NULL
  [07:00:51.296]                   if (!has_future || version < "1.8.0") {
  [07:00:51.296]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:00:51.296]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:00:51.296]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:00:51.296]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:00:51.296]                         "release", "version")], collapse = " "), 
  [07:00:51.296]                       hostname = base::Sys.info()[["nodename"]])
  [07:00:51.296]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:00:51.296]                       info)
  [07:00:51.296]                     info <- base::paste(info, collapse = "; ")
  [07:00:51.296]                     if (!has_future) {
  [07:00:51.296]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:00:51.296]                         info)
  [07:00:51.296]                     }
  [07:00:51.296]                     else {
  [07:00:51.296]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:00:51.296]                         info, version)
  [07:00:51.296]                     }
  [07:00:51.296]                     base::stop(msg)
  [07:00:51.296]                   }
  [07:00:51.296]                 })
  [07:00:51.296]             }
  [07:00:51.296]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:00:51.296]         }
  [07:00:51.296]     }
  [07:00:51.296]     if (base::is.na(TRUE)) {
  [07:00:51.296]     }
  [07:00:51.296]     else {
  [07:00:51.296]         if (TRUE) {
  [07:00:51.296]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:00:51.296]                 open = "w")
  [07:00:51.296]         }
  [07:00:51.296]         else {
  [07:00:51.296]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:00:51.296]                 windows = "NUL", "/dev/null"), open = "w")
  [07:00:51.296]         }
  [07:00:51.296]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:00:51.296]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:00:51.296]             base::sink(type = "output", split = FALSE)
  [07:00:51.296]             base::close(...future.stdout)
  [07:00:51.296]         }, add = TRUE)
  [07:00:51.296]     }
  [07:00:51.296]     ...future.frame <- base::sys.nframe()
  [07:00:51.296]     ...future.conditions <- base::list()
  [07:00:51.296]     ...future.rng <- base::globalenv()$.Random.seed
  [07:00:51.296]     ...future.result <- base::tryCatch({
  [07:00:51.296]         base::withCallingHandlers({
  [07:00:51.296]             ...future.value <- base::withVisible(base::local(42L))
  [07:00:51.296]             future::FutureResult(value = ...future.value$value, 
  [07:00:51.296]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:00:51.296]                   ...future.rng), started = ...future.startTime, 
  [07:00:51.296]                 version = "1.8")
  [07:00:51.296]         }, condition = base::local({
  [07:00:51.296]             c <- base::c
  [07:00:51.296]             inherits <- base::inherits
  [07:00:51.296]             invokeRestart <- base::invokeRestart
  [07:00:51.296]             length <- base::length
  [07:00:51.296]             list <- base::list
  [07:00:51.296]             seq.int <- base::seq.int
  [07:00:51.296]             signalCondition <- base::signalCondition
  [07:00:51.296]             sys.calls <- base::sys.calls
  [07:00:51.296]             Sys.time <- base::Sys.time
  [07:00:51.296]             `[[` <- base::`[[`
  [07:00:51.296]             `+` <- base::`+`
  [07:00:51.296]             `<<-` <- base::`<<-`
  [07:00:51.296]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:00:51.296]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:00:51.296]                   3L)]
  [07:00:51.296]             }
  [07:00:51.296]             function(cond) {
  [07:00:51.296]                 if (inherits(cond, "error")) {
  [07:00:51.296]                   sessionInformation <- function() {
  [07:00:51.296]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:00:51.296]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:00:51.296]                       search = base::search(), system = base::Sys.info())
  [07:00:51.296]                   }
  [07:00:51.296]                   ...future.conditions[[length(...future.conditions) + 
  [07:00:51.296]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:00:51.296]                     cond$call), session = sessionInformation(), 
  [07:00:51.296]                     timestamp = Sys.time(), signaled = 0L)
  [07:00:51.296]                   signalCondition(cond)
  [07:00:51.296]                 }
  [07:00:51.296]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:00:51.296]                 ))) {
  [07:00:51.296]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:00:51.296]                   ...future.conditions[[length(...future.conditions) + 
  [07:00:51.296]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:00:51.296]                   if (!signal) {
  [07:00:51.296]                     muffleCondition <- function (cond) 
  [07:00:51.296]                     {
  [07:00:51.296]                       inherits <- base::inherits
  [07:00:51.296]                       invokeRestart <- base::invokeRestart
  [07:00:51.296]                       muffled <- FALSE
  [07:00:51.296]                       if (inherits(cond, "message")) {
  [07:00:51.296]                         invokeRestart("muffleMessage")
  [07:00:51.296]                         muffled <- TRUE
  [07:00:51.296]                       }
  [07:00:51.296]                       else if (inherits(cond, "warning")) {
  [07:00:51.296]                         invokeRestart("muffleWarning")
  [07:00:51.296]                         muffled <- TRUE
  [07:00:51.296]                       }
  [07:00:51.296]                       else if (inherits(cond, "condition")) {
  [07:00:51.296]                         computeRestarts <- base::computeRestarts
  [07:00:51.296]                         grepl <- base::grepl
  [07:00:51.296]                         is.null <- base::is.null
  [07:00:51.296]                         restarts <- computeRestarts(cond)
  [07:00:51.296]                         for (restart in restarts) {
  [07:00:51.296]                           name <- restart$name
  [07:00:51.296]                           if (is.null(name)) 
  [07:00:51.296]                             next
  [07:00:51.296]                           if (!grepl("^muffle", name)) 
  [07:00:51.296]                             next
  [07:00:51.296]                           invokeRestart(restart)
  [07:00:51.296]                           muffled <- TRUE
  [07:00:51.296]                           break
  [07:00:51.296]                         }
  [07:00:51.296]                       }
  [07:00:51.296]                       invisible(muffled)
  [07:00:51.296]                     }
  [07:00:51.296]                     muffleCondition(cond)
  [07:00:51.296]                   }
  [07:00:51.296]                 }
  [07:00:51.296]             }
  [07:00:51.296]         }))
  [07:00:51.296]     }, error = function(ex) {
  [07:00:51.296]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:00:51.296]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:00:51.296]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:00:51.296]     }, finally = {
  [07:00:51.296]         {
  [07:00:51.296]             NULL
  [07:00:51.296]             future::plan(list(function (...) 
  [07:00:51.296]             {
  [07:00:51.296]                 Future(1)
  [07:00:51.296]             }), .cleanup = FALSE, .init = FALSE)
  [07:00:51.296]         }
  [07:00:51.296]         base::options(...future.oldOptions)
  [07:00:51.296]     })
  [07:00:51.296]     Sys.time
  [07:00:51.296]     if (base::is.na(TRUE)) {
  [07:00:51.296]     }
  [07:00:51.296]     else {
  [07:00:51.296]         base::sink(type = "output", split = FALSE)
  [07:00:51.296]         if (TRUE) {
  [07:00:51.296]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:00:51.296]         }
  [07:00:51.296]         else {
  [07:00:51.296]             ...future.result["stdout"] <- base::list(NULL)
  [07:00:51.296]         }
  [07:00:51.296]         base::close(...future.stdout)
  [07:00:51.296]         ...future.stdout <- NULL
  [07:00:51.296]     }
  [07:00:51.296]     ...future.result$conditions <- ...future.conditions
  [07:00:51.296]     ...future.result
  [07:00:51.296] }
  [07:00:51.300] plan(): Setting new future strategy stack:
  [07:00:51.301] List of future strategies:
  [07:00:51.301] 1. sequential:
  [07:00:51.301]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:00:51.301]    - tweaked: FALSE
  [07:00:51.301]    - call: NULL
  [07:00:51.301] plan(): nbrOfWorkers() = 1
  [07:00:51.305] plan(): Setting new future strategy stack:
  [07:00:51.305] List of future strategies:
  [07:00:51.305] 1. future:
  [07:00:51.305]    - args: function (...)
  [07:00:51.305]    - tweaked: FALSE
  [07:00:51.305]    - call: plan(foo)
  [07:00:51.306] plan(): nbrOfWorkers() = Inf
  [07:00:51.306] SequentialFuture started (and completed)
  [1] 42
  [07:00:51.308] getGlobalsAndPackages() ...
  [07:00:51.308] Searching for globals...
  [07:00:51.309] 
  [07:00:51.309] Searching for globals ... DONE
  [07:00:51.309] - globals: [0] <none>
  [07:00:51.309] getGlobalsAndPackages() ... DONE
  [07:00:51.311] Packages needed by the future expression (n = 0): <none>
  [07:00:51.311] Packages needed by future strategies (n = 0): <none>
  [07:00:51.314] {
  [07:00:51.314]     {
  [07:00:51.314]         ...future.startTime <- base::Sys.time()
  [07:00:51.314]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:00:51.314]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:00:51.314]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:00:51.314]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:00:51.314]             future.resolve.recursive = NULL, width = 80L)
  [07:00:51.314]         {
  [07:00:51.314]             {
  [07:00:51.314]                 base::local({
  [07:00:51.314]                   has_future <- base::requireNamespace("future", 
  [07:00:51.314]                     quietly = TRUE)
  [07:00:51.314]                   version <- if (has_future) 
  [07:00:51.314]                     utils::packageVersion("future")
  [07:00:51.314]                   else NULL
  [07:00:51.314]                   if (!has_future || version < "1.8.0") {
  [07:00:51.314]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:00:51.314]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:00:51.314]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:00:51.314]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:00:51.314]                         "release", "version")], collapse = " "), 
  [07:00:51.314]                       hostname = base::Sys.info()[["nodename"]])
  [07:00:51.314]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:00:51.314]                       info)
  [07:00:51.314]                     info <- base::paste(info, collapse = "; ")
  [07:00:51.314]                     if (!has_future) {
  [07:00:51.314]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:00:51.314]                         info)
  [07:00:51.314]                     }
  [07:00:51.314]                     else {
  [07:00:51.314]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:00:51.314]                         info, version)
  [07:00:51.314]                     }
  [07:00:51.314]                     base::stop(msg)
  [07:00:51.314]                   }
  [07:00:51.314]                 })
  [07:00:51.314]             }
  [07:00:51.314]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:00:51.314]         }
  [07:00:51.314]     }
  [07:00:51.314]     if (base::is.na(TRUE)) {
  [07:00:51.314]     }
  [07:00:51.314]     else {
  [07:00:51.314]         if (TRUE) {
  [07:00:51.314]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:00:51.314]                 open = "w")
  [07:00:51.314]         }
  [07:00:51.314]         else {
  [07:00:51.314]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:00:51.314]                 windows = "NUL", "/dev/null"), open = "w")
  [07:00:51.314]         }
  [07:00:51.314]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:00:51.314]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:00:51.314]             base::sink(type = "output", split = FALSE)
  [07:00:51.314]             base::close(...future.stdout)
  [07:00:51.314]         }, add = TRUE)
  [07:00:51.314]     }
  [07:00:51.314]     ...future.frame <- base::sys.nframe()
  [07:00:51.314]     ...future.conditions <- base::list()
  [07:00:51.314]     ...future.rng <- base::globalenv()$.Random.seed
  [07:00:51.314]     ...future.result <- base::tryCatch({
  [07:00:51.314]         base::withCallingHandlers({
  [07:00:51.314]             ...future.value <- base::withVisible(base::local(42L))
  [07:00:51.314]             future::FutureResult(value = ...future.value$value, 
  [07:00:51.314]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:00:51.314]                   ...future.rng), started = ...future.startTime, 
  [07:00:51.314]                 version = "1.8")
  [07:00:51.314]         }, condition = base::local({
  [07:00:51.314]             c <- base::c
  [07:00:51.314]             inherits <- base::inherits
  [07:00:51.314]             invokeRestart <- base::invokeRestart
  [07:00:51.314]             length <- base::length
  [07:00:51.314]             list <- base::list
  [07:00:51.314]             seq.int <- base::seq.int
  [07:00:51.314]             signalCondition <- base::signalCondition
  [07:00:51.314]             sys.calls <- base::sys.calls
  [07:00:51.314]             Sys.time <- base::Sys.time
  [07:00:51.314]             `[[` <- base::`[[`
  [07:00:51.314]             `+` <- base::`+`
  [07:00:51.314]             `<<-` <- base::`<<-`
  [07:00:51.314]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:00:51.314]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:00:51.314]                   3L)]
  [07:00:51.314]             }
  [07:00:51.314]             function(cond) {
  [07:00:51.314]                 if (inherits(cond, "error")) {
  [07:00:51.314]                   sessionInformation <- function() {
  [07:00:51.314]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:00:51.314]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:00:51.314]                       search = base::search(), system = base::Sys.info())
  [07:00:51.314]                   }
  [07:00:51.314]                   ...future.conditions[[length(...future.conditions) + 
  [07:00:51.314]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:00:51.314]                     cond$call), session = sessionInformation(), 
  [07:00:51.314]                     timestamp = Sys.time(), signaled = 0L)
  [07:00:51.314]                   signalCondition(cond)
  [07:00:51.314]                 }
  [07:00:51.314]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:00:51.314]                 ))) {
  [07:00:51.314]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:00:51.314]                   ...future.conditions[[length(...future.conditions) + 
  [07:00:51.314]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:00:51.314]                   if (!signal) {
  [07:00:51.314]                     muffleCondition <- function (cond) 
  [07:00:51.314]                     {
  [07:00:51.314]                       inherits <- base::inherits
  [07:00:51.314]                       invokeRestart <- base::invokeRestart
  [07:00:51.314]                       muffled <- FALSE
  [07:00:51.314]                       if (inherits(cond, "message")) {
  [07:00:51.314]                         invokeRestart("muffleMessage")
  [07:00:51.314]                         muffled <- TRUE
  [07:00:51.314]                       }
  [07:00:51.314]                       else if (inherits(cond, "warning")) {
  [07:00:51.314]                         invokeRestart("muffleWarning")
  [07:00:51.314]                         muffled <- TRUE
  [07:00:51.314]                       }
  [07:00:51.314]                       else if (inherits(cond, "condition")) {
  [07:00:51.314]                         computeRestarts <- base::computeRestarts
  [07:00:51.314]                         grepl <- base::grepl
  [07:00:51.314]                         is.null <- base::is.null
  [07:00:51.314]                         restarts <- computeRestarts(cond)
  [07:00:51.314]                         for (restart in restarts) {
  [07:00:51.314]                           name <- restart$name
  [07:00:51.314]                           if (is.null(name)) 
  [07:00:51.314]                             next
  [07:00:51.314]                           if (!grepl("^muffle", name)) 
  [07:00:51.314]                             next
  [07:00:51.314]                           invokeRestart(restart)
  [07:00:51.314]                           muffled <- TRUE
  [07:00:51.314]                           break
  [07:00:51.314]                         }
  [07:00:51.314]                       }
  [07:00:51.314]                       invisible(muffled)
  [07:00:51.314]                     }
  [07:00:51.314]                     muffleCondition(cond)
  [07:00:51.314]                   }
  [07:00:51.314]                 }
  [07:00:51.314]             }
  [07:00:51.314]         }))
  [07:00:51.314]     }, error = function(ex) {
  [07:00:51.314]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:00:51.314]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:00:51.314]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:00:51.314]     }, finally = {
  [07:00:51.314]         {
  [07:00:51.314]             NULL
  [07:00:51.314]             future::plan(list(function (...) 
  [07:00:51.314]             {
  [07:00:51.314]                 Future(1)
  [07:00:51.314]             }), .cleanup = FALSE, .init = FALSE)
  [07:00:51.314]         }
  [07:00:51.314]         base::options(...future.oldOptions)
  [07:00:51.314]     })
  [07:00:51.314]     Sys.time
  [07:00:51.314]     if (base::is.na(TRUE)) {
  [07:00:51.314]     }
  [07:00:51.314]     else {
  [07:00:51.314]         base::sink(type = "output", split = FALSE)
  [07:00:51.314]         if (TRUE) {
  [07:00:51.314]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:00:51.314]         }
  [07:00:51.314]         else {
  [07:00:51.314]             ...future.result["stdout"] <- base::list(NULL)
  [07:00:51.314]         }
  [07:00:51.314]         base::close(...future.stdout)
  [07:00:51.314]         ...future.stdout <- NULL
  [07:00:51.314]     }
  [07:00:51.314]     ...future.result$conditions <- ...future.conditions
  [07:00:51.314]     ...future.result
  [07:00:51.314] }
  [07:00:51.318] plan(): Setting new future strategy stack:
  [07:00:51.319] List of future strategies:
  [07:00:51.319] 1. sequential:
  [07:00:51.319]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:00:51.319]    - tweaked: FALSE
  [07:00:51.319]    - call: NULL
  [07:00:51.319] plan(): nbrOfWorkers() = 1
  [07:00:51.320] plan(): Setting new future strategy stack:
  [07:00:51.320] List of future strategies:
  [07:00:51.320] 1. future:
  [07:00:51.320]    - args: function (...)
  [07:00:51.320]    - tweaked: FALSE
  [07:00:51.320]    - call: plan(foo)
  [07:00:51.321] plan(): nbrOfWorkers() = Inf
  [07:00:51.321] SequentialFuture started (and completed)
  [1] 42
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 35797
  [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/Rtmpk6JOTc/working_dir/Rtmpki0qle/future.parent=654894.9fe2e438b87e5.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmpk6JOTc/working_dir/Rtmpki0qle/future.parent=654894.9fe2e438b87e5.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:654894' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpk6JOTc/working_dir/Rtmpki0qle/future.parent=654894.9fe2e438b87e5.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=35797 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 655022) if still alive
  [07:02:52.164] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(654894, signal = 0L)
  [1] TRUE
  Call: tools::pskill(654894, signal = 0L)
  [1] TRUE
  [07:02:52.165] - success
  [07:02:52.165] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 655022) 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 35797 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:654894' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpk6JOTc/working_dir/Rtmpki0qle/future.parent=654894.9fe2e438b87e5.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=35797 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 655022) 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")
  [07:02:54.008] plan(): Setting new future strategy stack:
  [07:02:54.010] List of future strategies:
  [07:02:54.010] 1. sequential:
  [07:02:54.010]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:02:54.010]    - tweaked: FALSE
  [07:02:54.010]    - call: future::plan("sequential")
  [07:02:54.011] 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: 38758
  [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/Rtmpk6JOTc/working_dir/RtmpORZc9w/future.parent=659514.a103a503ccc0f.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmpk6JOTc/working_dir/RtmpORZc9w/future.parent=659514.a103a503ccc0f.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:659514' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpk6JOTc/working_dir/RtmpORZc9w/future.parent=659514.a103a503ccc0f.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=38758 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 659562) if still alive
  [07:04:54.811] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(659514, signal = 0L)
  [1] TRUE
  Call: tools::pskill(659514, signal = 0L)
  [1] TRUE
  [07:04:54.812] - success
  [07:04:54.812] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 659562) 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 38758 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:659514' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpk6JOTc/working_dir/RtmpORZc9w/future.parent=659514.a103a503ccc0f.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=38758 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 659562) 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")
  [07:04:58.012] plan(): Setting new future strategy stack:
  [07:04:58.013] List of future strategies:
  [07:04:58.013] 1. sequential:
  [07:04:58.013]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:04:58.013]    - tweaked: FALSE
  [07:04:58.013]    - call: future::plan("sequential")
  [07:04:58.014] 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): 662225
  > 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: 429405e3-786c-33d3-7982-03ac0e2836ba
  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 21235 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:662225' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpk6JOTc/working_dir/Rtmp61suuy/future.parent=662225.a1ad1445cfb33.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=21235 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 662270) 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")
  [07:07:00.993] plan(): Setting new future strategy stack:
  [07:07:00.995] List of future strategies:
  [07:07:00.995] 1. sequential:
  [07:07:00.995]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:00.995]    - tweaked: FALSE
  [07:07:00.995]    - call: future::plan("sequential")
  [07:07:00.998] 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)
  [07:07:01.035] plan(): Setting new future strategy stack:
  [07:07:01.035] List of future strategies:
  [07:07:01.035] 1. sequential:
  [07:07:01.035]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:01.035]    - tweaked: FALSE
  [07:07:01.035]    - call: plan(sequential)
  [07:07:01.074] 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"
  + }
  [07:07:01.110] getGlobalsAndPackages() ...
  [07:07:01.111] Searching for globals...
  [07:07:01.125] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.126] Searching for globals ... DONE
  [07:07:01.127] Resolving globals: FALSE
  [07:07:01.130] The total size of the 2 globals is 224 bytes (224 bytes)
  [07:07:01.131] - globals: [2] 'x', 'i'
  [07:07:01.132] 
  [07:07:01.132] getGlobalsAndPackages() ... DONE
  [07:07:01.135] getGlobalsAndPackages() ...
  [07:07:01.135] Searching for globals...
  [07:07:01.140] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.141] Searching for globals ... DONE
  [07:07:01.142] Resolving globals: FALSE
  [07:07:01.144] The total size of the 2 globals is 8.10 KiB (8296 bytes)
  [07:07:01.145] - globals: [2] 'x', 'i'
  [07:07:01.146] 
  [07:07:01.146] getGlobalsAndPackages() ... DONE
  [07:07:01.148] getGlobalsAndPackages() ...
  [07:07:01.149] Searching for globals...
  [07:07:01.154] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.154] Searching for globals ... DONE
  [07:07:01.155] Resolving globals: FALSE
  [07:07:01.159] The total size of the 2 globals is 16.15 KiB (16536 bytes)
  [07:07:01.160] - globals: [2] 'x', 'i'
  [07:07:01.161] 
  [07:07:01.161] getGlobalsAndPackages() ... DONE
  [07:07:01.163] getGlobalsAndPackages() ...
  [07:07:01.164] Searching for globals...
  [07:07:01.168] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.169] Searching for globals ... DONE
  [07:07:01.169] Resolving globals: FALSE
  [07:07:01.174] The total size of the 2 globals is 24.20 KiB (24776 bytes)
  [07:07:01.174] - globals: [2] 'x', 'i'
  [07:07:01.175] 
  [07:07:01.175] getGlobalsAndPackages() ... DONE
  [07:07:01.177] getGlobalsAndPackages() ...
  [07:07:01.178] Searching for globals...
  [07:07:01.181] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.182] Searching for globals ... DONE
  [07:07:01.182] Resolving globals: FALSE
  [07:07:01.188] The total size of the 2 globals is 32.24 KiB (33016 bytes)
  [07:07:01.189] - globals: [2] 'x', 'i'
  [07:07:01.190] 
  [07:07:01.190] getGlobalsAndPackages() ... DONE
  [07:07:01.192] getGlobalsAndPackages() ...
  [07:07:01.193] Searching for globals...
  [07:07:01.197] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.198] Searching for globals ... DONE
  [07:07:01.199] Resolving globals: FALSE
  [07:07:01.206] The total size of the 2 globals is 40.29 KiB (41256 bytes)
  [07:07:01.207] - globals: [2] 'x', 'i'
  [07:07:01.207] 
  [07:07:01.208] getGlobalsAndPackages() ... DONE
  [07:07:01.210] getGlobalsAndPackages() ...
  [07:07:01.211] Searching for globals...
  [07:07:01.215] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.216] Searching for globals ... DONE
  [07:07:01.217] Resolving globals: FALSE
  [07:07:01.230] The total size of the 2 globals is 48.34 KiB (49496 bytes)
  [07:07:01.230] - globals: [2] 'x', 'i'
  [07:07:01.231] 
  [07:07:01.232] getGlobalsAndPackages() ... DONE
  [07:07:01.234] getGlobalsAndPackages() ...
  [07:07:01.234] Searching for globals...
  [07:07:01.239] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.240] Searching for globals ... DONE
  [07:07:01.240] Resolving globals: FALSE
  [07:07:01.250] The total size of the 2 globals is 56.38 KiB (57736 bytes)
  [07:07:01.251] - globals: [2] 'x', 'i'
  [07:07:01.251] 
  [07:07:01.252] getGlobalsAndPackages() ... DONE
  [07:07:01.254] getGlobalsAndPackages() ...
  [07:07:01.255] Searching for globals...
  [07:07:01.260] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.260] Searching for globals ... DONE
  [07:07:01.261] Resolving globals: FALSE
  [07:07:01.272] The total size of the 2 globals is 64.43 KiB (65976 bytes)
  [07:07:01.272] - globals: [2] 'x', 'i'
  [07:07:01.273] 
  [07:07:01.274] getGlobalsAndPackages() ... DONE
  [07:07:01.276] getGlobalsAndPackages() ...
  [07:07:01.276] Searching for globals...
  [07:07:01.281] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.282] Searching for globals ... DONE
  [07:07:01.282] Resolving globals: FALSE
  [07:07:01.294] The total size of the 2 globals is 72.48 KiB (74216 bytes)
  [07:07:01.295] - globals: [2] 'x', 'i'
  [07:07:01.295] 
  [07:07:01.296] getGlobalsAndPackages() ... DONE
  [07:07:01.297] getGlobalsAndPackages() ...
  [07:07:01.298] Searching for globals...
  [07:07:01.302] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.303] Searching for globals ... DONE
  [07:07:01.303] Resolving globals: FALSE
  [07:07:01.314] The total size of the 2 globals is 80.52 KiB (82456 bytes)
  [07:07:01.315] - globals: [2] 'x', 'i'
  [07:07:01.315] 
  [07:07:01.316] getGlobalsAndPackages() ... DONE
  [07:07:01.318] getGlobalsAndPackages() ...
  [07:07:01.319] Searching for globals...
  [07:07:01.327] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.328] Searching for globals ... DONE
  [07:07:01.328] Resolving globals: FALSE
  [07:07:01.342] The total size of the 2 globals is 88.57 KiB (90696 bytes)
  [07:07:01.343] - globals: [2] 'x', 'i'
  [07:07:01.344] 
  [07:07:01.344] getGlobalsAndPackages() ... DONE
  [07:07:01.346] getGlobalsAndPackages() ...
  [07:07:01.347] Searching for globals...
  [07:07:01.352] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.352] Searching for globals ... DONE
  [07:07:01.353] Resolving globals: FALSE
  [07:07:01.368] The total size of the 2 globals is 96.62 KiB (98936 bytes)
  [07:07:01.369] - globals: [2] 'x', 'i'
  [07:07:01.370] 
  [07:07:01.370] getGlobalsAndPackages() ... DONE
  [07:07:01.373] getGlobalsAndPackages() ...
  [07:07:01.373] Searching for globals...
  [07:07:01.378] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.379] Searching for globals ... DONE
  [07:07:01.379] Resolving globals: FALSE
  [07:07:01.396] The total size of the 2 globals is 104.66 KiB (107176 bytes)
  [07:07:01.397] - globals: [2] 'x', 'i'
  [07:07:01.398] 
  [07:07:01.398] getGlobalsAndPackages() ... DONE
  [07:07:01.400] getGlobalsAndPackages() ...
  [07:07:01.401] Searching for globals...
  [07:07:01.406] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.407] Searching for globals ... DONE
  [07:07:01.407] Resolving globals: FALSE
  [07:07:01.426] The total size of the 2 globals is 112.71 KiB (115416 bytes)
  [07:07:01.427] - globals: [2] 'x', 'i'
  [07:07:01.428] 
  [07:07:01.428] getGlobalsAndPackages() ... DONE
  [07:07:01.430] getGlobalsAndPackages() ...
  [07:07:01.430] Searching for globals...
  [07:07:01.435] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.435] Searching for globals ... DONE
  [07:07:01.436] Resolving globals: FALSE
  [07:07:01.452] The total size of the 2 globals is 120.76 KiB (123656 bytes)
  [07:07:01.453] - globals: [2] 'x', 'i'
  [07:07:01.453] 
  [07:07:01.454] getGlobalsAndPackages() ... DONE
  [07:07:01.456] getGlobalsAndPackages() ...
  [07:07:01.456] Searching for globals...
  [07:07:01.461] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.461] Searching for globals ... DONE
  [07:07:01.462] Resolving globals: FALSE
  [07:07:01.478] The total size of the 2 globals is 128.80 KiB (131896 bytes)
  [07:07:01.479] - globals: [2] 'x', 'i'
  [07:07:01.479] 
  [07:07:01.480] getGlobalsAndPackages() ... DONE
  [07:07:01.482] getGlobalsAndPackages() ...
  [07:07:01.482] Searching for globals...
  [07:07:01.486] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.487] Searching for globals ... DONE
  [07:07:01.488] Resolving globals: FALSE
  [07:07:01.505] The total size of the 2 globals is 136.85 KiB (140136 bytes)
  [07:07:01.509] - globals: [2] 'x', 'i'
  [07:07:01.510] 
  [07:07:01.510] getGlobalsAndPackages() ... DONE
  [07:07:01.513] getGlobalsAndPackages() ...
  [07:07:01.514] Searching for globals...
  [07:07:01.520] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.520] Searching for globals ... DONE
  [07:07:01.521] Resolving globals: FALSE
  [07:07:01.543] The total size of the 2 globals is 144.90 KiB (148376 bytes)
  [07:07:01.544] - globals: [2] 'x', 'i'
  [07:07:01.544] 
  [07:07:01.545] getGlobalsAndPackages() ... DONE
  [07:07:01.547] getGlobalsAndPackages() ...
  [07:07:01.548] Searching for globals...
  [07:07:01.552] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.553] Searching for globals ... DONE
  [07:07:01.554] Resolving globals: FALSE
  [07:07:01.577] The total size of the 2 globals is 152.95 KiB (156616 bytes)
  [07:07:01.577] - globals: [2] 'x', 'i'
  [07:07:01.578] 
  [07:07:01.578] getGlobalsAndPackages() ... DONE
  [07:07:01.581] getGlobalsAndPackages() ...
  [07:07:01.581] Searching for globals...
  [07:07:01.586] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.587] Searching for globals ... DONE
  [07:07:01.587] Resolving globals: FALSE
  [07:07:01.614] The total size of the 2 globals is 160.99 KiB (164856 bytes)
  [07:07:01.615] - globals: [2] 'x', 'i'
  [07:07:01.615] 
  [07:07:01.616] getGlobalsAndPackages() ... DONE
  [07:07:01.618] getGlobalsAndPackages() ...
  [07:07:01.619] Searching for globals...
  [07:07:01.623] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.624] Searching for globals ... DONE
  [07:07:01.625] Resolving globals: FALSE
  [07:07:01.650] The total size of the 2 globals is 169.04 KiB (173096 bytes)
  [07:07:01.651] - globals: [2] 'x', 'i'
  [07:07:01.652] 
  [07:07:01.652] getGlobalsAndPackages() ... DONE
  [07:07:01.654] getGlobalsAndPackages() ...
  [07:07:01.655] Searching for globals...
  [07:07:01.660] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.660] Searching for globals ... DONE
  [07:07:01.661] Resolving globals: FALSE
  [07:07:01.688] The total size of the 2 globals is 177.09 KiB (181336 bytes)
  [07:07:01.689] - globals: [2] 'x', 'i'
  [07:07:01.689] 
  [07:07:01.690] getGlobalsAndPackages() ... DONE
  [07:07:01.692] getGlobalsAndPackages() ...
  [07:07:01.693] Searching for globals...
  [07:07:01.701] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.702] Searching for globals ... DONE
  [07:07:01.702] Resolving globals: FALSE
  [07:07:01.732] The total size of the 2 globals is 185.13 KiB (189576 bytes)
  [07:07:01.732] - globals: [2] 'x', 'i'
  [07:07:01.733] 
  [07:07:01.734] getGlobalsAndPackages() ... DONE
  [07:07:01.736] getGlobalsAndPackages() ...
  [07:07:01.736] Searching for globals...
  [07:07:01.741] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.742] Searching for globals ... DONE
  [07:07:01.743] Resolving globals: FALSE
  [07:07:01.771] The total size of the 2 globals is 193.18 KiB (197816 bytes)
  [07:07:01.772] - globals: [2] 'x', 'i'
  [07:07:01.773] 
  [07:07:01.773] getGlobalsAndPackages() ... DONE
  [07:07:01.775] getGlobalsAndPackages() ...
  [07:07:01.776] Searching for globals...
  [07:07:01.781] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.782] Searching for globals ... DONE
  [07:07:01.782] Resolving globals: FALSE
  [07:07:01.816] The total size of the 2 globals is 201.23 KiB (206056 bytes)
  [07:07:01.817] - globals: [2] 'x', 'i'
  [07:07:01.818] 
  [07:07:01.818] getGlobalsAndPackages() ... DONE
  [07:07:01.820] getGlobalsAndPackages() ...
  [07:07:01.821] Searching for globals...
  [07:07:01.826] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.827] Searching for globals ... DONE
  [07:07:01.827] Resolving globals: FALSE
  [07:07:01.859] The total size of the 2 globals is 209.27 KiB (214296 bytes)
  [07:07:01.860] - globals: [2] 'x', 'i'
  [07:07:01.860] 
  [07:07:01.861] getGlobalsAndPackages() ... DONE
  [07:07:01.863] getGlobalsAndPackages() ...
  [07:07:01.864] Searching for globals...
  [07:07:01.868] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.869] Searching for globals ... DONE
  [07:07:01.870] Resolving globals: FALSE
  [07:07:01.904] The total size of the 2 globals is 217.32 KiB (222536 bytes)
  [07:07:01.905] - globals: [2] 'x', 'i'
  [07:07:01.905] 
  [07:07:01.906] getGlobalsAndPackages() ... DONE
  [07:07:01.907] getGlobalsAndPackages() ...
  [07:07:01.908] Searching for globals...
  [07:07:01.912] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.913] Searching for globals ... DONE
  [07:07:01.913] Resolving globals: FALSE
  [07:07:01.946] The total size of the 2 globals is 225.37 KiB (230776 bytes)
  [07:07:01.947] - globals: [2] 'x', 'i'
  [07:07:01.948] 
  [07:07:01.948] getGlobalsAndPackages() ... DONE
  [07:07:01.951] getGlobalsAndPackages() ...
  [07:07:01.951] Searching for globals...
  [07:07:01.956] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:01.957] Searching for globals ... DONE
  [07:07:01.958] Resolving globals: FALSE
  [07:07:01.996] The total size of the 2 globals is 233.41 KiB (239016 bytes)
  [07:07:01.997] - globals: [2] 'x', 'i'
  [07:07:01.997] 
  [07:07:01.998] getGlobalsAndPackages() ... DONE
  [07:07:02.000] getGlobalsAndPackages() ...
  [07:07:02.000] Searching for globals...
  [07:07:02.005] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.006] Searching for globals ... DONE
  [07:07:02.007] Resolving globals: FALSE
  [07:07:02.042] The total size of the 2 globals is 241.46 KiB (247256 bytes)
  [07:07:02.043] - globals: [2] 'x', 'i'
  [07:07:02.044] 
  [07:07:02.044] getGlobalsAndPackages() ... DONE
  [07:07:02.046] getGlobalsAndPackages() ...
  [07:07:02.047] Searching for globals...
  [07:07:02.052] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.053] Searching for globals ... DONE
  [07:07:02.053] Resolving globals: FALSE
  [07:07:02.093] The total size of the 2 globals is 249.51 KiB (255496 bytes)
  [07:07:02.094] - globals: [2] 'x', 'i'
  [07:07:02.095] 
  [07:07:02.095] getGlobalsAndPackages() ... DONE
  [07:07:02.098] getGlobalsAndPackages() ...
  [07:07:02.098] Searching for globals...
  [07:07:02.103] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.104] Searching for globals ... DONE
  [07:07:02.105] Resolving globals: FALSE
  [07:07:02.146] The total size of the 2 globals is 257.55 KiB (263736 bytes)
  [07:07:02.147] - globals: [2] 'x', 'i'
  [07:07:02.148] 
  [07:07:02.148] getGlobalsAndPackages() ... DONE
  [07:07:02.150] getGlobalsAndPackages() ...
  [07:07:02.151] Searching for globals...
  [07:07:02.156] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.157] Searching for globals ... DONE
  [07:07:02.157] Resolving globals: FALSE
  [07:07:02.196] The total size of the 2 globals is 265.60 KiB (271976 bytes)
  [07:07:02.197] - globals: [2] 'x', 'i'
  [07:07:02.197] 
  [07:07:02.198] getGlobalsAndPackages() ... DONE
  [07:07:02.200] getGlobalsAndPackages() ...
  [07:07:02.201] Searching for globals...
  [07:07:02.206] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.206] Searching for globals ... DONE
  [07:07:02.207] Resolving globals: FALSE
  [07:07:02.252] The total size of the 2 globals is 273.65 KiB (280216 bytes)
  [07:07:02.253] - globals: [2] 'x', 'i'
  [07:07:02.254] 
  [07:07:02.254] getGlobalsAndPackages() ... DONE
  [07:07:02.257] getGlobalsAndPackages() ...
  [07:07:02.257] Searching for globals...
  [07:07:02.262] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.263] Searching for globals ... DONE
  [07:07:02.264] Resolving globals: FALSE
  [07:07:02.302] The total size of the 2 globals is 281.70 KiB (288456 bytes)
  [07:07:02.303] - globals: [2] 'x', 'i'
  [07:07:02.304] 
  [07:07:02.304] getGlobalsAndPackages() ... DONE
  [07:07:02.306] getGlobalsAndPackages() ...
  [07:07:02.307] Searching for globals...
  [07:07:02.314] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.315] Searching for globals ... DONE
  [07:07:02.316] Resolving globals: FALSE
  [07:07:02.357] The total size of the 2 globals is 289.74 KiB (296696 bytes)
  [07:07:02.358] - globals: [2] 'x', 'i'
  [07:07:02.359] 
  [07:07:02.359] getGlobalsAndPackages() ... DONE
  [07:07:02.361] getGlobalsAndPackages() ...
  [07:07:02.362] Searching for globals...
  [07:07:02.367] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.367] Searching for globals ... DONE
  [07:07:02.368] Resolving globals: FALSE
  [07:07:02.416] The total size of the 2 globals is 297.79 KiB (304936 bytes)
  [07:07:02.417] - globals: [2] 'x', 'i'
  [07:07:02.417] 
  [07:07:02.418] getGlobalsAndPackages() ... DONE
  [07:07:02.420] getGlobalsAndPackages() ...
  [07:07:02.421] Searching for globals...
  [07:07:02.425] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.426] Searching for globals ... DONE
  [07:07:02.427] Resolving globals: FALSE
  [07:07:02.473] The total size of the 2 globals is 305.84 KiB (313176 bytes)
  [07:07:02.474] - globals: [2] 'x', 'i'
  [07:07:02.475] 
  [07:07:02.475] getGlobalsAndPackages() ... DONE
  [07:07:02.480] getGlobalsAndPackages() ...
  [07:07:02.481] Searching for globals...
  [07:07:02.485] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.486] Searching for globals ... DONE
  [07:07:02.487] Resolving globals: FALSE
  [07:07:02.533] The total size of the 2 globals is 313.88 KiB (321416 bytes)
  [07:07:02.534] - globals: [2] 'x', 'i'
  [07:07:02.535] 
  [07:07:02.535] getGlobalsAndPackages() ... DONE
  [07:07:02.537] getGlobalsAndPackages() ...
  [07:07:02.538] Searching for globals...
  [07:07:02.543] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.544] Searching for globals ... DONE
  [07:07:02.544] Resolving globals: FALSE
  [07:07:02.597] The total size of the 2 globals is 321.93 KiB (329656 bytes)
  [07:07:02.598] - globals: [2] 'x', 'i'
  [07:07:02.599] 
  [07:07:02.599] getGlobalsAndPackages() ... DONE
  [07:07:02.601] getGlobalsAndPackages() ...
  [07:07:02.602] Searching for globals...
  [07:07:02.607] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.608] Searching for globals ... DONE
  [07:07:02.608] Resolving globals: FALSE
  [07:07:02.659] The total size of the 2 globals is 329.98 KiB (337896 bytes)
  [07:07:02.660] - globals: [2] 'x', 'i'
  [07:07:02.661] 
  [07:07:02.661] getGlobalsAndPackages() ... DONE
  [07:07:02.664] getGlobalsAndPackages() ...
  [07:07:02.664] Searching for globals...
  [07:07:02.669] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.669] Searching for globals ... DONE
  [07:07:02.670] Resolving globals: FALSE
  [07:07:02.716] The total size of the 2 globals is 338.02 KiB (346136 bytes)
  [07:07:02.717] - globals: [2] 'x', 'i'
  [07:07:02.718] 
  [07:07:02.718] getGlobalsAndPackages() ... DONE
  [07:07:02.723] getGlobalsAndPackages() ...
  [07:07:02.725] Searching for globals...
  [07:07:02.730] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.730] Searching for globals ... DONE
  [07:07:02.731] Resolving globals: FALSE
  [07:07:02.784] The total size of the 2 globals is 346.07 KiB (354376 bytes)
  [07:07:02.785] - globals: [2] 'x', 'i'
  [07:07:02.786] 
  [07:07:02.786] getGlobalsAndPackages() ... DONE
  [07:07:02.788] getGlobalsAndPackages() ...
  [07:07:02.789] Searching for globals...
  [07:07:02.793] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.794] Searching for globals ... DONE
  [07:07:02.795] Resolving globals: FALSE
  [07:07:02.890] The total size of the 2 globals is 354.12 KiB (362616 bytes)
  [07:07:02.891] - globals: [2] 'x', 'i'
  [07:07:02.892] 
  [07:07:02.892] getGlobalsAndPackages() ... DONE
  [07:07:02.894] getGlobalsAndPackages() ...
  [07:07:02.895] Searching for globals...
  [07:07:02.900] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.901] Searching for globals ... DONE
  [07:07:02.901] Resolving globals: FALSE
  [07:07:02.957] The total size of the 2 globals is 362.16 KiB (370856 bytes)
  [07:07:02.958] - globals: [2] 'x', 'i'
  [07:07:02.959] 
  [07:07:02.959] getGlobalsAndPackages() ... DONE
  [07:07:02.961] getGlobalsAndPackages() ...
  [07:07:02.962] Searching for globals...
  [07:07:02.967] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:02.968] Searching for globals ... DONE
  [07:07:02.968] Resolving globals: FALSE
  [07:07:03.026] The total size of the 2 globals is 370.21 KiB (379096 bytes)
  [07:07:03.027] - globals: [2] 'x', 'i'
  [07:07:03.027] 
  [07:07:03.028] getGlobalsAndPackages() ... DONE
  [07:07:03.030] getGlobalsAndPackages() ...
  [07:07:03.031] Searching for globals...
  [07:07:03.035] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.036] Searching for globals ... DONE
  [07:07:03.036] Resolving globals: FALSE
  [07:07:03.089] The total size of the 2 globals is 378.26 KiB (387336 bytes)
  [07:07:03.089] - globals: [2] 'x', 'i'
  [07:07:03.093] 
  [07:07:03.093] getGlobalsAndPackages() ... DONE
  [07:07:03.095] getGlobalsAndPackages() ...
  [07:07:03.096] Searching for globals...
  [07:07:03.101] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.102] Searching for globals ... DONE
  [07:07:03.102] Resolving globals: FALSE
  [07:07:03.159] The total size of the 2 globals is 386.30 KiB (395576 bytes)
  [07:07:03.160] - globals: [2] 'x', 'i'
  [07:07:03.160] 
  [07:07:03.161] getGlobalsAndPackages() ... DONE
  [07:07:03.163] getGlobalsAndPackages() ...
  [07:07:03.164] Searching for globals...
  [07:07:03.168] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.169] Searching for globals ... DONE
  [07:07:03.170] Resolving globals: FALSE
  [07:07:03.231] The total size of the 2 globals is 394.35 KiB (403816 bytes)
  [07:07:03.232] - globals: [2] 'x', 'i'
  [07:07:03.232] 
  [07:07:03.233] getGlobalsAndPackages() ... DONE
  [07:07:03.235] getGlobalsAndPackages() ...
  [07:07:03.235] Searching for globals...
  [07:07:03.240] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.241] Searching for globals ... DONE
  [07:07:03.242] Resolving globals: FALSE
  [07:07:03.304] The total size of the 2 globals is 402.40 KiB (412056 bytes)
  [07:07:03.305] - globals: [2] 'x', 'i'
  [07:07:03.306] 
  [07:07:03.306] getGlobalsAndPackages() ... DONE
  [07:07:03.308] getGlobalsAndPackages() ...
  [07:07:03.309] Searching for globals...
  [07:07:03.314] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.314] Searching for globals ... DONE
  [07:07:03.315] Resolving globals: FALSE
  [07:07:03.379] The total size of the 2 globals is 410.45 KiB (420296 bytes)
  [07:07:03.380] - globals: [2] 'x', 'i'
  [07:07:03.380] 
  [07:07:03.381] getGlobalsAndPackages() ... DONE
  [07:07:03.383] getGlobalsAndPackages() ...
  [07:07:03.384] Searching for globals...
  [07:07:03.388] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.389] Searching for globals ... DONE
  [07:07:03.390] Resolving globals: FALSE
  [07:07:03.450] The total size of the 2 globals is 418.49 KiB (428536 bytes)
  [07:07:03.450] - globals: [2] 'x', 'i'
  [07:07:03.451] 
  [07:07:03.452] getGlobalsAndPackages() ... DONE
  [07:07:03.454] getGlobalsAndPackages() ...
  [07:07:03.454] Searching for globals...
  [07:07:03.459] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.460] Searching for globals ... DONE
  [07:07:03.460] Resolving globals: FALSE
  [07:07:03.528] The total size of the 2 globals is 426.54 KiB (436776 bytes)
  [07:07:03.529] - globals: [2] 'x', 'i'
  [07:07:03.529] 
  [07:07:03.530] getGlobalsAndPackages() ... DONE
  [07:07:03.532] getGlobalsAndPackages() ...
  [07:07:03.532] Searching for globals...
  [07:07:03.537] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.537] Searching for globals ... DONE
  [07:07:03.538] Resolving globals: FALSE
  [07:07:03.594] The total size of the 2 globals is 434.59 KiB (445016 bytes)
  [07:07:03.595] - globals: [2] 'x', 'i'
  [07:07:03.596] 
  [07:07:03.596] getGlobalsAndPackages() ... DONE
  [07:07:03.598] getGlobalsAndPackages() ...
  [07:07:03.598] Searching for globals...
  [07:07:03.602] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.603] Searching for globals ... DONE
  [07:07:03.604] Resolving globals: FALSE
  [07:07:03.664] The total size of the 2 globals is 442.63 KiB (453256 bytes)
  [07:07:03.664] - globals: [2] 'x', 'i'
  [07:07:03.665] 
  [07:07:03.665] getGlobalsAndPackages() ... DONE
  [07:07:03.667] getGlobalsAndPackages() ...
  [07:07:03.668] Searching for globals...
  [07:07:03.672] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.673] Searching for globals ... DONE
  [07:07:03.674] Resolving globals: FALSE
  [07:07:03.737] The total size of the 2 globals is 450.68 KiB (461496 bytes)
  [07:07:03.738] - globals: [2] 'x', 'i'
  [07:07:03.738] 
  [07:07:03.739] getGlobalsAndPackages() ... DONE
  [07:07:03.741] getGlobalsAndPackages() ...
  [07:07:03.741] Searching for globals...
  [07:07:03.746] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.746] Searching for globals ... DONE
  [07:07:03.747] Resolving globals: FALSE
  [07:07:03.810] The total size of the 2 globals is 458.73 KiB (469736 bytes)
  [07:07:03.811] - globals: [2] 'x', 'i'
  [07:07:03.811] 
  [07:07:03.812] getGlobalsAndPackages() ... DONE
  [07:07:03.814] getGlobalsAndPackages() ...
  [07:07:03.814] Searching for globals...
  [07:07:03.818] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.819] Searching for globals ... DONE
  [07:07:03.820] Resolving globals: FALSE
  [07:07:03.879] The total size of the 2 globals is 466.77 KiB (477976 bytes)
  [07:07:03.880] - globals: [2] 'x', 'i'
  [07:07:03.880] 
  [07:07:03.881] getGlobalsAndPackages() ... DONE
  [07:07:03.882] getGlobalsAndPackages() ...
  [07:07:03.883] Searching for globals...
  [07:07:03.887] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.888] Searching for globals ... DONE
  [07:07:03.888] Resolving globals: FALSE
  [07:07:03.950] The total size of the 2 globals is 474.82 KiB (486216 bytes)
  [07:07:03.951] - globals: [2] 'x', 'i'
  [07:07:03.952] 
  [07:07:03.952] getGlobalsAndPackages() ... DONE
  [07:07:03.954] getGlobalsAndPackages() ...
  [07:07:03.955] Searching for globals...
  [07:07:03.959] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:03.960] Searching for globals ... DONE
  [07:07:03.961] Resolving globals: FALSE
  [07:07:04.036] The total size of the 2 globals is 482.87 KiB (494456 bytes)
  [07:07:04.036] - globals: [2] 'x', 'i'
  [07:07:04.037] 
  [07:07:04.038] getGlobalsAndPackages() ... DONE
  [07:07:04.040] getGlobalsAndPackages() ...
  [07:07:04.040] Searching for globals...
  [07:07:04.045] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:04.045] Searching for globals ... DONE
  [07:07:04.046] Resolving globals: FALSE
  [07:07:04.112] The total size of the 2 globals is 490.91 KiB (502696 bytes)
  [07:07:04.113] - globals: [2] 'x', 'i'
  [07:07:04.114] 
  [07:07:04.114] getGlobalsAndPackages() ... DONE
  [07:07:04.116] getGlobalsAndPackages() ...
  [07:07:04.117] Searching for globals...
  [07:07:04.121] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:04.121] Searching for globals ... DONE
  [07:07:04.122] Resolving globals: FALSE
  [07:07:04.190] The total size of the 2 globals is 498.96 KiB (510936 bytes)
  [07:07:04.191] - globals: [2] 'x', 'i'
  [07:07:04.191] 
  [07:07:04.192] getGlobalsAndPackages() ... DONE
  [07:07:04.194] getGlobalsAndPackages() ...
  [07:07:04.195] Searching for globals...
  [07:07:04.199] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:04.199] Searching for globals ... DONE
  [07:07:04.200] Resolving globals: FALSE
  [07:07:04.267] The total size of the 2 globals is 507.01 KiB (519176 bytes)
  [07:07:04.268] - globals: [2] 'x', 'i'
  [07:07:04.268] 
  [07:07:04.269] getGlobalsAndPackages() ... DONE
  [07:07:04.270] getGlobalsAndPackages() ...
  [07:07:04.271] Searching for globals...
  [07:07:04.275] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:04.276] Searching for globals ... DONE
  [07:07:04.276] Resolving globals: FALSE
  [07:07:04.345] The total size of the 2 globals is 515.05 KiB (527416 bytes)
  [07:07:04.346] - globals: [2] 'x', 'i'
  [07:07:04.346] 
  [07:07:04.347] getGlobalsAndPackages() ... DONE
  [07:07:04.349] getGlobalsAndPackages() ...
  [07:07:04.349] Searching for globals...
  [07:07:04.354] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:04.354] Searching for globals ... DONE
  [07:07:04.355] Resolving globals: FALSE
  [07:07:04.428] The total size of the 2 globals is 523.10 KiB (535656 bytes)
  [07:07:04.429] - globals: [2] 'x', 'i'
  [07:07:04.430] 
  [07:07:04.430] getGlobalsAndPackages() ... DONE
  [07:07:04.432] getGlobalsAndPackages() ...
  [07:07:04.433] Searching for globals...
  [07:07:04.437] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:04.438] Searching for globals ... DONE
  [07:07:04.438] Resolving globals: FALSE
  [07:07:04.512] The total size of the 2 globals is 531.15 KiB (543896 bytes)
  [07:07:04.513] - globals: [2] 'x', 'i'
  [07:07:04.513] 
  [07:07:04.514] getGlobalsAndPackages() ... DONE
  [07:07:04.516] getGlobalsAndPackages() ...
  [07:07:04.516] Searching for globals...
  [07:07:04.520] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:04.521] Searching for globals ... DONE
  [07:07:04.522] Resolving globals: FALSE
  [07:07:04.600] The total size of the 2 globals is 539.20 KiB (552136 bytes)
  [07:07:04.600] - globals: [2] 'x', 'i'
  [07:07:04.601] 
  [07:07:04.601] getGlobalsAndPackages() ... DONE
  [07:07:04.603] getGlobalsAndPackages() ...
  [07:07:04.604] Searching for globals...
  [07:07:04.608] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:04.609] Searching for globals ... DONE
  [07:07:04.610] Resolving globals: FALSE
  [07:07:04.683] The total size of the 2 globals is 547.24 KiB (560376 bytes)
  [07:07:04.683] - globals: [2] 'x', 'i'
  [07:07:04.684] 
  [07:07:04.684] getGlobalsAndPackages() ... DONE
  [07:07:04.685] getGlobalsAndPackages() ...
  [07:07:04.686] Searching for globals...
  [07:07:04.688] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:04.689] Searching for globals ... DONE
  [07:07:04.689] Resolving globals: FALSE
  [07:07:04.770] The total size of the 2 globals is 555.29 KiB (568616 bytes)
  [07:07:04.770] - globals: [2] 'x', 'i'
  [07:07:04.771] 
  [07:07:04.771] getGlobalsAndPackages() ... DONE
  [07:07:04.773] getGlobalsAndPackages() ...
  [07:07:04.774] Searching for globals...
  [07:07:04.779] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:04.779] Searching for globals ... DONE
  [07:07:04.780] Resolving globals: FALSE
  [07:07:04.864] The total size of the 2 globals is 563.34 KiB (576856 bytes)
  [07:07:04.865] - globals: [2] 'x', 'i'
  [07:07:04.865] 
  [07:07:04.866] getGlobalsAndPackages() ... DONE
  [07:07:04.868] getGlobalsAndPackages() ...
  [07:07:04.868] Searching for globals...
  [07:07:04.873] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:04.874] Searching for globals ... DONE
  [07:07:04.874] Resolving globals: FALSE
  [07:07:04.963] The total size of the 2 globals is 571.38 KiB (585096 bytes)
  [07:07:04.964] - globals: [2] 'x', 'i'
  [07:07:04.964] 
  [07:07:04.965] getGlobalsAndPackages() ... DONE
  [07:07:04.967] getGlobalsAndPackages() ...
  [07:07:04.968] Searching for globals...
  [07:07:04.972] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:04.973] Searching for globals ... DONE
  [07:07:04.973] Resolving globals: FALSE
  [07:07:05.064] The total size of the 2 globals is 579.43 KiB (593336 bytes)
  [07:07:05.065] - globals: [2] 'x', 'i'
  [07:07:05.066] 
  [07:07:05.066] getGlobalsAndPackages() ... DONE
  [07:07:05.069] getGlobalsAndPackages() ...
  [07:07:05.069] Searching for globals...
  [07:07:05.074] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:05.075] Searching for globals ... DONE
  [07:07:05.075] Resolving globals: FALSE
  [07:07:05.164] The total size of the 2 globals is 587.48 KiB (601576 bytes)
  [07:07:05.165] - globals: [2] 'x', 'i'
  [07:07:05.165] 
  [07:07:05.166] getGlobalsAndPackages() ... DONE
  [07:07:05.168] getGlobalsAndPackages() ...
  [07:07:05.168] Searching for globals...
  [07:07:05.176] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:05.176] Searching for globals ... DONE
  [07:07:05.177] Resolving globals: FALSE
  [07:07:05.263] The total size of the 2 globals is 595.52 KiB (609816 bytes)
  [07:07:05.264] - globals: [2] 'x', 'i'
  [07:07:05.265] 
  [07:07:05.265] getGlobalsAndPackages() ... DONE
  [07:07:05.267] getGlobalsAndPackages() ...
  [07:07:05.268] Searching for globals...
  [07:07:05.272] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:05.273] Searching for globals ... DONE
  [07:07:05.273] Resolving globals: FALSE
  [07:07:05.364] The total size of the 2 globals is 603.57 KiB (618056 bytes)
  [07:07:05.365] - globals: [2] 'x', 'i'
  [07:07:05.365] 
  [07:07:05.366] getGlobalsAndPackages() ... DONE
  [07:07:05.368] getGlobalsAndPackages() ...
  [07:07:05.369] Searching for globals...
  [07:07:05.374] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:05.374] Searching for globals ... DONE
  [07:07:05.375] Resolving globals: FALSE
  [07:07:05.476] The total size of the 2 globals is 611.62 KiB (626296 bytes)
  [07:07:05.477] - globals: [2] 'x', 'i'
  [07:07:05.477] 
  [07:07:05.478] getGlobalsAndPackages() ... DONE
  [07:07:05.480] getGlobalsAndPackages() ...
  [07:07:05.480] Searching for globals...
  [07:07:05.485] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:05.486] Searching for globals ... DONE
  [07:07:05.486] Resolving globals: FALSE
  [07:07:05.579] The total size of the 2 globals is 619.66 KiB (634536 bytes)
  [07:07:05.580] - globals: [2] 'x', 'i'
  [07:07:05.581] 
  [07:07:05.581] getGlobalsAndPackages() ... DONE
  [07:07:05.583] getGlobalsAndPackages() ...
  [07:07:05.584] Searching for globals...
  [07:07:05.589] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:05.589] Searching for globals ... DONE
  [07:07:05.590] Resolving globals: FALSE
  [07:07:05.687] The total size of the 2 globals is 627.71 KiB (642776 bytes)
  [07:07:05.688] - globals: [2] 'x', 'i'
  [07:07:05.688] 
  [07:07:05.689] getGlobalsAndPackages() ... DONE
  [07:07:05.691] getGlobalsAndPackages() ...
  [07:07:05.692] Searching for globals...
  [07:07:05.696] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:05.697] Searching for globals ... DONE
  [07:07:05.698] Resolving globals: FALSE
  [07:07:05.800] The total size of the 2 globals is 635.76 KiB (651016 bytes)
  [07:07:05.801] - globals: [2] 'x', 'i'
  [07:07:05.802] 
  [07:07:05.803] getGlobalsAndPackages() ... DONE
  [07:07:05.805] getGlobalsAndPackages() ...
  [07:07:05.805] Searching for globals...
  [07:07:05.810] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:05.811] Searching for globals ... DONE
  [07:07:05.812] Resolving globals: FALSE
  [07:07:05.915] The total size of the 2 globals is 643.80 KiB (659256 bytes)
  [07:07:05.916] - globals: [2] 'x', 'i'
  [07:07:05.916] 
  [07:07:05.917] getGlobalsAndPackages() ... DONE
  [07:07:05.919] getGlobalsAndPackages() ...
  [07:07:05.920] Searching for globals...
  [07:07:05.925] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:05.925] Searching for globals ... DONE
  [07:07:05.926] Resolving globals: FALSE
  [07:07:06.027] The total size of the 2 globals is 651.85 KiB (667496 bytes)
  [07:07:06.028] - globals: [2] 'x', 'i'
  [07:07:06.029] 
  [07:07:06.029] getGlobalsAndPackages() ... DONE
  [07:07:06.031] getGlobalsAndPackages() ...
  [07:07:06.032] Searching for globals...
  [07:07:06.037] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:06.038] Searching for globals ... DONE
  [07:07:06.039] Resolving globals: FALSE
  [07:07:06.144] The total size of the 2 globals is 659.90 KiB (675736 bytes)
  [07:07:06.145] - globals: [2] 'x', 'i'
  [07:07:06.146] 
  [07:07:06.146] getGlobalsAndPackages() ... DONE
  [07:07:06.149] getGlobalsAndPackages() ...
  [07:07:06.149] Searching for globals...
  [07:07:06.154] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:06.155] Searching for globals ... DONE
  [07:07:06.156] Resolving globals: FALSE
  [07:07:06.257] The total size of the 2 globals is 667.95 KiB (683976 bytes)
  [07:07:06.258] - globals: [2] 'x', 'i'
  [07:07:06.259] 
  [07:07:06.259] getGlobalsAndPackages() ... DONE
  [07:07:06.264] getGlobalsAndPackages() ...
  [07:07:06.265] Searching for globals...
  [07:07:06.270] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:06.271] Searching for globals ... DONE
  [07:07:06.272] Resolving globals: FALSE
  [07:07:06.374] The total size of the 2 globals is 675.99 KiB (692216 bytes)
  [07:07:06.375] - globals: [2] 'x', 'i'
  [07:07:06.376] 
  [07:07:06.376] getGlobalsAndPackages() ... DONE
  [07:07:06.378] getGlobalsAndPackages() ...
  [07:07:06.378] Searching for globals...
  [07:07:06.383] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:06.383] Searching for globals ... DONE
  [07:07:06.384] Resolving globals: FALSE
  [07:07:06.494] The total size of the 2 globals is 684.04 KiB (700456 bytes)
  [07:07:06.494] - globals: [2] 'x', 'i'
  [07:07:06.495] 
  [07:07:06.496] getGlobalsAndPackages() ... DONE
  [07:07:06.498] getGlobalsAndPackages() ...
  [07:07:06.498] Searching for globals...
  [07:07:06.503] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:06.504] Searching for globals ... DONE
  [07:07:06.505] Resolving globals: FALSE
  [07:07:06.617] The total size of the 2 globals is 692.09 KiB (708696 bytes)
  [07:07:06.618] - globals: [2] 'x', 'i'
  [07:07:06.619] 
  [07:07:06.619] getGlobalsAndPackages() ... DONE
  [07:07:06.622] getGlobalsAndPackages() ...
  [07:07:06.622] Searching for globals...
  [07:07:06.627] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:06.628] Searching for globals ... DONE
  [07:07:06.629] Resolving globals: FALSE
  [07:07:06.749] The total size of the 2 globals is 700.13 KiB (716936 bytes)
  [07:07:06.750] - globals: [2] 'x', 'i'
  [07:07:06.750] 
  [07:07:06.751] getGlobalsAndPackages() ... DONE
  [07:07:06.753] getGlobalsAndPackages() ...
  [07:07:06.754] Searching for globals...
  [07:07:06.759] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:06.759] Searching for globals ... DONE
  [07:07:06.760] Resolving globals: FALSE
  [07:07:06.877] The total size of the 2 globals is 708.18 KiB (725176 bytes)
  [07:07:06.878] - globals: [2] 'x', 'i'
  [07:07:06.878] 
  [07:07:06.879] getGlobalsAndPackages() ... DONE
  [07:07:06.881] getGlobalsAndPackages() ...
  [07:07:06.882] Searching for globals...
  [07:07:06.887] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:06.887] Searching for globals ... DONE
  [07:07:06.888] Resolving globals: FALSE
  [07:07:07.009] The total size of the 2 globals is 716.23 KiB (733416 bytes)
  [07:07:07.010] - globals: [2] 'x', 'i'
  [07:07:07.011] 
  [07:07:07.011] getGlobalsAndPackages() ... DONE
  [07:07:07.014] getGlobalsAndPackages() ...
  [07:07:07.014] Searching for globals...
  [07:07:07.019] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:07.020] Searching for globals ... DONE
  [07:07:07.021] Resolving globals: FALSE
  [07:07:07.137] The total size of the 2 globals is 724.27 KiB (741656 bytes)
  [07:07:07.138] - globals: [2] 'x', 'i'
  [07:07:07.139] 
  [07:07:07.139] getGlobalsAndPackages() ... DONE
  [07:07:07.141] getGlobalsAndPackages() ...
  [07:07:07.142] Searching for globals...
  [07:07:07.147] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:07.147] Searching for globals ... DONE
  [07:07:07.148] Resolving globals: FALSE
  [07:07:07.266] The total size of the 2 globals is 732.32 KiB (749896 bytes)
  [07:07:07.266] - globals: [2] 'x', 'i'
  [07:07:07.267] 
  [07:07:07.268] getGlobalsAndPackages() ... DONE
  [07:07:07.270] getGlobalsAndPackages() ...
  [07:07:07.270] Searching for globals...
  [07:07:07.275] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:07.276] Searching for globals ... DONE
  [07:07:07.277] Resolving globals: FALSE
  [07:07:07.404] The total size of the 2 globals is 740.37 KiB (758136 bytes)
  [07:07:07.405] - globals: [2] 'x', 'i'
  [07:07:07.405] 
  [07:07:07.406] getGlobalsAndPackages() ... DONE
  [07:07:07.408] getGlobalsAndPackages() ...
  [07:07:07.409] Searching for globals...
  [07:07:07.414] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:07.415] Searching for globals ... DONE
  [07:07:07.415] Resolving globals: FALSE
  [07:07:07.543] The total size of the 2 globals is 748.41 KiB (766376 bytes)
  [07:07:07.544] - globals: [2] 'x', 'i'
  [07:07:07.545] 
  [07:07:07.545] getGlobalsAndPackages() ... DONE
  [07:07:07.547] getGlobalsAndPackages() ...
  [07:07:07.548] Searching for globals...
  [07:07:07.553] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:07.554] Searching for globals ... DONE
  [07:07:07.555] Resolving globals: FALSE
  [07:07:07.679] The total size of the 2 globals is 756.46 KiB (774616 bytes)
  [07:07:07.680] - globals: [2] 'x', 'i'
  [07:07:07.680] 
  [07:07:07.681] getGlobalsAndPackages() ... DONE
  [07:07:07.683] getGlobalsAndPackages() ...
  [07:07:07.684] Searching for globals...
  [07:07:07.690] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:07.691] Searching for globals ... DONE
  [07:07:07.692] Resolving globals: FALSE
  [07:07:07.822] The total size of the 2 globals is 764.51 KiB (782856 bytes)
  [07:07:07.822] - globals: [2] 'x', 'i'
  [07:07:07.823] 
  [07:07:07.824] getGlobalsAndPackages() ... DONE
  [07:07:07.826] getGlobalsAndPackages() ...
  [07:07:07.827] Searching for globals...
  [07:07:07.832] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:07.833] Searching for globals ... DONE
  [07:07:07.833] Resolving globals: FALSE
  [07:07:07.959] The total size of the 2 globals is 772.55 KiB (791096 bytes)
  [07:07:07.960] - globals: [2] 'x', 'i'
  [07:07:07.961] 
  [07:07:07.961] getGlobalsAndPackages() ... DONE
  [07:07:07.967] getGlobalsAndPackages() ...
  [07:07:07.967] Searching for globals...
  [07:07:07.973] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:07:07.974] Searching for globals ... DONE
  [07:07:07.974] Resolving globals: FALSE
  [07:07:08.101] The total size of the 2 globals is 780.60 KiB (799336 bytes)
  [07:07:08.102] - globals: [2] 'x', 'i'
  [07:07:08.103] 
  [07:07:08.103] 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]])
  [07:07:08.109] Packages needed by the future expression (n = 0): <none>
  [07:07:08.110] Packages needed by future strategies (n = 0): <none>
  [07:07:08.123] {
  [07:07:08.123]     {
  [07:07:08.123]         ...future.startTime <- base::Sys.time()
  [07:07:08.123]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.123]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.123]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:07:08.123]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.123]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.123]         {
  [07:07:08.123]             {
  [07:07:08.123]                 base::local({
  [07:07:08.123]                   has_future <- base::requireNamespace("future", 
  [07:07:08.123]                     quietly = TRUE)
  [07:07:08.123]                   version <- if (has_future) 
  [07:07:08.123]                     utils::packageVersion("future")
  [07:07:08.123]                   else NULL
  [07:07:08.123]                   if (!has_future || version < "1.8.0") {
  [07:07:08.123]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.123]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.123]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.123]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.123]                         "release", "version")], collapse = " "), 
  [07:07:08.123]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.123]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.123]                       info)
  [07:07:08.123]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.123]                     if (!has_future) {
  [07:07:08.123]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.123]                         info)
  [07:07:08.123]                     }
  [07:07:08.123]                     else {
  [07:07:08.123]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.123]                         info, version)
  [07:07:08.123]                     }
  [07:07:08.123]                     base::stop(msg)
  [07:07:08.123]                   }
  [07:07:08.123]                 })
  [07:07:08.123]             }
  [07:07:08.123]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.123]         }
  [07:07:08.123]     }
  [07:07:08.123]     if (base::is.na(NA)) {
  [07:07:08.123]     }
  [07:07:08.123]     else {
  [07:07:08.123]         if (NA) {
  [07:07:08.123]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.123]                 open = "w")
  [07:07:08.123]         }
  [07:07:08.123]         else {
  [07:07:08.123]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.123]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.123]         }
  [07:07:08.123]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.123]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.123]             base::sink(type = "output", split = FALSE)
  [07:07:08.123]             base::close(...future.stdout)
  [07:07:08.123]         }, add = TRUE)
  [07:07:08.123]     }
  [07:07:08.123]     ...future.frame <- base::sys.nframe()
  [07:07:08.123]     ...future.conditions <- base::list()
  [07:07:08.123]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.123]     ...future.result <- base::tryCatch({
  [07:07:08.123]         base::withCallingHandlers({
  [07:07:08.123]             ...future.value <- base::withVisible(base::local({
  [07:07:08.123]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.123]             }))
  [07:07:08.123]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.123]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.123]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.123]                 version = "1.8")
  [07:07:08.123]         }, condition = base::local({
  [07:07:08.123]             c <- base::c
  [07:07:08.123]             inherits <- base::inherits
  [07:07:08.123]             invokeRestart <- base::invokeRestart
  [07:07:08.123]             length <- base::length
  [07:07:08.123]             list <- base::list
  [07:07:08.123]             seq.int <- base::seq.int
  [07:07:08.123]             signalCondition <- base::signalCondition
  [07:07:08.123]             sys.calls <- base::sys.calls
  [07:07:08.123]             Sys.time <- base::Sys.time
  [07:07:08.123]             `[[` <- base::`[[`
  [07:07:08.123]             `+` <- base::`+`
  [07:07:08.123]             `<<-` <- base::`<<-`
  [07:07:08.123]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.123]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.123]                   3L)]
  [07:07:08.123]             }
  [07:07:08.123]             function(cond) {
  [07:07:08.123]                 if (inherits(cond, "error")) {
  [07:07:08.123]                   sessionInformation <- function() {
  [07:07:08.123]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.123]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.123]                       search = base::search(), system = base::Sys.info())
  [07:07:08.123]                   }
  [07:07:08.123]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.123]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.123]                     cond$call), session = sessionInformation(), 
  [07:07:08.123]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.123]                   signalCondition(cond)
  [07:07:08.123]                 }
  [07:07:08.123]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.123]                 ))) {
  [07:07:08.123]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.123]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.123]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.123]                   if (!signal) {
  [07:07:08.123]                     muffleCondition <- function (cond) 
  [07:07:08.123]                     {
  [07:07:08.123]                       inherits <- base::inherits
  [07:07:08.123]                       invokeRestart <- base::invokeRestart
  [07:07:08.123]                       muffled <- FALSE
  [07:07:08.123]                       if (inherits(cond, "message")) {
  [07:07:08.123]                         invokeRestart("muffleMessage")
  [07:07:08.123]                         muffled <- TRUE
  [07:07:08.123]                       }
  [07:07:08.123]                       else if (inherits(cond, "warning")) {
  [07:07:08.123]                         invokeRestart("muffleWarning")
  [07:07:08.123]                         muffled <- TRUE
  [07:07:08.123]                       }
  [07:07:08.123]                       else if (inherits(cond, "condition")) {
  [07:07:08.123]                         computeRestarts <- base::computeRestarts
  [07:07:08.123]                         grepl <- base::grepl
  [07:07:08.123]                         is.null <- base::is.null
  [07:07:08.123]                         restarts <- computeRestarts(cond)
  [07:07:08.123]                         for (restart in restarts) {
  [07:07:08.123]                           name <- restart$name
  [07:07:08.123]                           if (is.null(name)) 
  [07:07:08.123]                             next
  [07:07:08.123]                           if (!grepl("^muffle", name)) 
  [07:07:08.123]                             next
  [07:07:08.123]                           invokeRestart(restart)
  [07:07:08.123]                           muffled <- TRUE
  [07:07:08.123]                           break
  [07:07:08.123]                         }
  [07:07:08.123]                       }
  [07:07:08.123]                       invisible(muffled)
  [07:07:08.123]                     }
  [07:07:08.123]                     muffleCondition(cond)
  [07:07:08.123]                   }
  [07:07:08.123]                 }
  [07:07:08.123]             }
  [07:07:08.123]         }))
  [07:07:08.123]     }, error = function(ex) {
  [07:07:08.123]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.123]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.123]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.123]     }, finally = {
  [07:07:08.123]         {
  [07:07:08.123]             NULL
  [07:07:08.123]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.123]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.123]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.123]                 label = NULL, ...) 
  [07:07:08.123]             {
  [07:07:08.123]                 if (substitute) 
  [07:07:08.123]                   expr <- substitute(expr)
  [07:07:08.123]                 local <- as.logical(local)
  [07:07:08.123]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.123]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.123]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.123]                   label = label, ...)
  [07:07:08.123]                 if (!future$lazy) 
  [07:07:08.123]                   future <- run(future)
  [07:07:08.123]                 invisible(future)
  [07:07:08.123]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.123]         }
  [07:07:08.123]         base::options(...future.oldOptions)
  [07:07:08.123]     })
  [07:07:08.123]     Sys.time
  [07:07:08.123]     if (base::is.na(NA)) {
  [07:07:08.123]     }
  [07:07:08.123]     else {
  [07:07:08.123]         base::sink(type = "output", split = FALSE)
  [07:07:08.123]         if (NA) {
  [07:07:08.123]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.123]         }
  [07:07:08.123]         else {
  [07:07:08.123]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.123]         }
  [07:07:08.123]         base::close(...future.stdout)
  [07:07:08.123]         ...future.stdout <- NULL
  [07:07:08.123]     }
  [07:07:08.123]     ...future.result$conditions <- ...future.conditions
  [07:07:08.123]     ...future.result
  [07:07:08.123] }
  [07:07:08.132] plan(): Setting new future strategy stack:
  [07:07:08.133] List of future strategies:
  [07:07:08.133] 1. sequential:
  [07:07:08.133]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.133]    - tweaked: FALSE
  [07:07:08.133]    - call: NULL
  [07:07:08.134] plan(): nbrOfWorkers() = 1
  [07:07:08.138] Packages needed by the future expression (n = 0): <none>
  [07:07:08.139] Packages needed by future strategies (n = 0): <none>
  [07:07:08.147] {
  [07:07:08.147]     {
  [07:07:08.147]         ...future.startTime <- base::Sys.time()
  [07:07:08.147]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.147]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.147]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:07:08.147]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.147]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.147]         {
  [07:07:08.147]             {
  [07:07:08.147]                 base::local({
  [07:07:08.147]                   has_future <- base::requireNamespace("future", 
  [07:07:08.147]                     quietly = TRUE)
  [07:07:08.147]                   version <- if (has_future) 
  [07:07:08.147]                     utils::packageVersion("future")
  [07:07:08.147]                   else NULL
  [07:07:08.147]                   if (!has_future || version < "1.8.0") {
  [07:07:08.147]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.147]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.147]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.147]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.147]                         "release", "version")], collapse = " "), 
  [07:07:08.147]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.147]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.147]                       info)
  [07:07:08.147]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.147]                     if (!has_future) {
  [07:07:08.147]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.147]                         info)
  [07:07:08.147]                     }
  [07:07:08.147]                     else {
  [07:07:08.147]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.147]                         info, version)
  [07:07:08.147]                     }
  [07:07:08.147]                     base::stop(msg)
  [07:07:08.147]                   }
  [07:07:08.147]                 })
  [07:07:08.147]             }
  [07:07:08.147]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.147]         }
  [07:07:08.147]     }
  [07:07:08.147]     if (base::is.na(NA)) {
  [07:07:08.147]     }
  [07:07:08.147]     else {
  [07:07:08.147]         if (NA) {
  [07:07:08.147]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.147]                 open = "w")
  [07:07:08.147]         }
  [07:07:08.147]         else {
  [07:07:08.147]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.147]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.147]         }
  [07:07:08.147]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.147]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.147]             base::sink(type = "output", split = FALSE)
  [07:07:08.147]             base::close(...future.stdout)
  [07:07:08.147]         }, add = TRUE)
  [07:07:08.147]     }
  [07:07:08.147]     ...future.frame <- base::sys.nframe()
  [07:07:08.147]     ...future.conditions <- base::list()
  [07:07:08.147]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.147]     ...future.result <- base::tryCatch({
  [07:07:08.147]         base::withCallingHandlers({
  [07:07:08.147]             ...future.value <- base::withVisible(base::local({
  [07:07:08.147]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.147]             }))
  [07:07:08.147]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.147]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.147]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.147]                 version = "1.8")
  [07:07:08.147]         }, condition = base::local({
  [07:07:08.147]             c <- base::c
  [07:07:08.147]             inherits <- base::inherits
  [07:07:08.147]             invokeRestart <- base::invokeRestart
  [07:07:08.147]             length <- base::length
  [07:07:08.147]             list <- base::list
  [07:07:08.147]             seq.int <- base::seq.int
  [07:07:08.147]             signalCondition <- base::signalCondition
  [07:07:08.147]             sys.calls <- base::sys.calls
  [07:07:08.147]             Sys.time <- base::Sys.time
  [07:07:08.147]             `[[` <- base::`[[`
  [07:07:08.147]             `+` <- base::`+`
  [07:07:08.147]             `<<-` <- base::`<<-`
  [07:07:08.147]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.147]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.147]                   3L)]
  [07:07:08.147]             }
  [07:07:08.147]             function(cond) {
  [07:07:08.147]                 if (inherits(cond, "error")) {
  [07:07:08.147]                   sessionInformation <- function() {
  [07:07:08.147]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.147]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.147]                       search = base::search(), system = base::Sys.info())
  [07:07:08.147]                   }
  [07:07:08.147]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.147]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.147]                     cond$call), session = sessionInformation(), 
  [07:07:08.147]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.147]                   signalCondition(cond)
  [07:07:08.147]                 }
  [07:07:08.147]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.147]                 ))) {
  [07:07:08.147]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.147]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.147]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.147]                   if (!signal) {
  [07:07:08.147]                     muffleCondition <- function (cond) 
  [07:07:08.147]                     {
  [07:07:08.147]                       inherits <- base::inherits
  [07:07:08.147]                       invokeRestart <- base::invokeRestart
  [07:07:08.147]                       muffled <- FALSE
  [07:07:08.147]                       if (inherits(cond, "message")) {
  [07:07:08.147]                         invokeRestart("muffleMessage")
  [07:07:08.147]                         muffled <- TRUE
  [07:07:08.147]                       }
  [07:07:08.147]                       else if (inherits(cond, "warning")) {
  [07:07:08.147]                         invokeRestart("muffleWarning")
  [07:07:08.147]                         muffled <- TRUE
  [07:07:08.147]                       }
  [07:07:08.147]                       else if (inherits(cond, "condition")) {
  [07:07:08.147]                         computeRestarts <- base::computeRestarts
  [07:07:08.147]                         grepl <- base::grepl
  [07:07:08.147]                         is.null <- base::is.null
  [07:07:08.147]                         restarts <- computeRestarts(cond)
  [07:07:08.147]                         for (restart in restarts) {
  [07:07:08.147]                           name <- restart$name
  [07:07:08.147]                           if (is.null(name)) 
  [07:07:08.147]                             next
  [07:07:08.147]                           if (!grepl("^muffle", name)) 
  [07:07:08.147]                             next
  [07:07:08.147]                           invokeRestart(restart)
  [07:07:08.147]                           muffled <- TRUE
  [07:07:08.147]                           break
  [07:07:08.147]                         }
  [07:07:08.147]                       }
  [07:07:08.147]                       invisible(muffled)
  [07:07:08.147]                     }
  [07:07:08.147]                     muffleCondition(cond)
  [07:07:08.147]                   }
  [07:07:08.147]                 }
  [07:07:08.147]             }
  [07:07:08.147]         }))
  [07:07:08.147]     }, error = function(ex) {
  [07:07:08.147]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.147]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.147]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.147]     }, finally = {
  [07:07:08.147]         {
  [07:07:08.147]             NULL
  [07:07:08.147]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.147]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.147]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.147]                 label = NULL, ...) 
  [07:07:08.147]             {
  [07:07:08.147]                 if (substitute) 
  [07:07:08.147]                   expr <- substitute(expr)
  [07:07:08.147]                 local <- as.logical(local)
  [07:07:08.147]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.147]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.147]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.147]                   label = label, ...)
  [07:07:08.147]                 if (!future$lazy) 
  [07:07:08.147]                   future <- run(future)
  [07:07:08.147]                 invisible(future)
  [07:07:08.147]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.147]         }
  [07:07:08.147]         base::options(...future.oldOptions)
  [07:07:08.147]     })
  [07:07:08.147]     Sys.time
  [07:07:08.147]     if (base::is.na(NA)) {
  [07:07:08.147]     }
  [07:07:08.147]     else {
  [07:07:08.147]         base::sink(type = "output", split = FALSE)
  [07:07:08.147]         if (NA) {
  [07:07:08.147]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.147]         }
  [07:07:08.147]         else {
  [07:07:08.147]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.147]         }
  [07:07:08.147]         base::close(...future.stdout)
  [07:07:08.147]         ...future.stdout <- NULL
  [07:07:08.147]     }
  [07:07:08.147]     ...future.result$conditions <- ...future.conditions
  [07:07:08.147]     ...future.result
  [07:07:08.147] }
  [07:07:08.155] plan(): Setting new future strategy stack:
  [07:07:08.155] List of future strategies:
  [07:07:08.155] 1. sequential:
  [07:07:08.155]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.155]    - tweaked: FALSE
  [07:07:08.155]    - call: NULL
  [07:07:08.157] plan(): nbrOfWorkers() = 1
  [07:07:08.161] Packages needed by the future expression (n = 0): <none>
  [07:07:08.162] Packages needed by future strategies (n = 0): <none>
  [07:07:08.171] {
  [07:07:08.171]     {
  [07:07:08.171]         ...future.startTime <- base::Sys.time()
  [07:07:08.171]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.171]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.171]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:07:08.171]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.171]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.171]         {
  [07:07:08.171]             {
  [07:07:08.171]                 base::local({
  [07:07:08.171]                   has_future <- base::requireNamespace("future", 
  [07:07:08.171]                     quietly = TRUE)
  [07:07:08.171]                   version <- if (has_future) 
  [07:07:08.171]                     utils::packageVersion("future")
  [07:07:08.171]                   else NULL
  [07:07:08.171]                   if (!has_future || version < "1.8.0") {
  [07:07:08.171]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.171]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.171]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.171]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.171]                         "release", "version")], collapse = " "), 
  [07:07:08.171]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.171]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.171]                       info)
  [07:07:08.171]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.171]                     if (!has_future) {
  [07:07:08.171]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.171]                         info)
  [07:07:08.171]                     }
  [07:07:08.171]                     else {
  [07:07:08.171]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.171]                         info, version)
  [07:07:08.171]                     }
  [07:07:08.171]                     base::stop(msg)
  [07:07:08.171]                   }
  [07:07:08.171]                 })
  [07:07:08.171]             }
  [07:07:08.171]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.171]         }
  [07:07:08.171]     }
  [07:07:08.171]     if (base::is.na(NA)) {
  [07:07:08.171]     }
  [07:07:08.171]     else {
  [07:07:08.171]         if (NA) {
  [07:07:08.171]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.171]                 open = "w")
  [07:07:08.171]         }
  [07:07:08.171]         else {
  [07:07:08.171]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.171]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.171]         }
  [07:07:08.171]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.171]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.171]             base::sink(type = "output", split = FALSE)
  [07:07:08.171]             base::close(...future.stdout)
  [07:07:08.171]         }, add = TRUE)
  [07:07:08.171]     }
  [07:07:08.171]     ...future.frame <- base::sys.nframe()
  [07:07:08.171]     ...future.conditions <- base::list()
  [07:07:08.171]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.171]     ...future.result <- base::tryCatch({
  [07:07:08.171]         base::withCallingHandlers({
  [07:07:08.171]             ...future.value <- base::withVisible(base::local({
  [07:07:08.171]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.171]             }))
  [07:07:08.171]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.171]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.171]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.171]                 version = "1.8")
  [07:07:08.171]         }, condition = base::local({
  [07:07:08.171]             c <- base::c
  [07:07:08.171]             inherits <- base::inherits
  [07:07:08.171]             invokeRestart <- base::invokeRestart
  [07:07:08.171]             length <- base::length
  [07:07:08.171]             list <- base::list
  [07:07:08.171]             seq.int <- base::seq.int
  [07:07:08.171]             signalCondition <- base::signalCondition
  [07:07:08.171]             sys.calls <- base::sys.calls
  [07:07:08.171]             Sys.time <- base::Sys.time
  [07:07:08.171]             `[[` <- base::`[[`
  [07:07:08.171]             `+` <- base::`+`
  [07:07:08.171]             `<<-` <- base::`<<-`
  [07:07:08.171]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.171]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.171]                   3L)]
  [07:07:08.171]             }
  [07:07:08.171]             function(cond) {
  [07:07:08.171]                 if (inherits(cond, "error")) {
  [07:07:08.171]                   sessionInformation <- function() {
  [07:07:08.171]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.171]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.171]                       search = base::search(), system = base::Sys.info())
  [07:07:08.171]                   }
  [07:07:08.171]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.171]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.171]                     cond$call), session = sessionInformation(), 
  [07:07:08.171]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.171]                   signalCondition(cond)
  [07:07:08.171]                 }
  [07:07:08.171]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.171]                 ))) {
  [07:07:08.171]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.171]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.171]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.171]                   if (!signal) {
  [07:07:08.171]                     muffleCondition <- function (cond) 
  [07:07:08.171]                     {
  [07:07:08.171]                       inherits <- base::inherits
  [07:07:08.171]                       invokeRestart <- base::invokeRestart
  [07:07:08.171]                       muffled <- FALSE
  [07:07:08.171]                       if (inherits(cond, "message")) {
  [07:07:08.171]                         invokeRestart("muffleMessage")
  [07:07:08.171]                         muffled <- TRUE
  [07:07:08.171]                       }
  [07:07:08.171]                       else if (inherits(cond, "warning")) {
  [07:07:08.171]                         invokeRestart("muffleWarning")
  [07:07:08.171]                         muffled <- TRUE
  [07:07:08.171]                       }
  [07:07:08.171]                       else if (inherits(cond, "condition")) {
  [07:07:08.171]                         computeRestarts <- base::computeRestarts
  [07:07:08.171]                         grepl <- base::grepl
  [07:07:08.171]                         is.null <- base::is.null
  [07:07:08.171]                         restarts <- computeRestarts(cond)
  [07:07:08.171]                         for (restart in restarts) {
  [07:07:08.171]                           name <- restart$name
  [07:07:08.171]                           if (is.null(name)) 
  [07:07:08.171]                             next
  [07:07:08.171]                           if (!grepl("^muffle", name)) 
  [07:07:08.171]                             next
  [07:07:08.171]                           invokeRestart(restart)
  [07:07:08.171]                           muffled <- TRUE
  [07:07:08.171]                           break
  [07:07:08.171]                         }
  [07:07:08.171]                       }
  [07:07:08.171]                       invisible(muffled)
  [07:07:08.171]                     }
  [07:07:08.171]                     muffleCondition(cond)
  [07:07:08.171]                   }
  [07:07:08.171]                 }
  [07:07:08.171]             }
  [07:07:08.171]         }))
  [07:07:08.171]     }, error = function(ex) {
  [07:07:08.171]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.171]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.171]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.171]     }, finally = {
  [07:07:08.171]         {
  [07:07:08.171]             NULL
  [07:07:08.171]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.171]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.171]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.171]                 label = NULL, ...) 
  [07:07:08.171]             {
  [07:07:08.171]                 if (substitute) 
  [07:07:08.171]                   expr <- substitute(expr)
  [07:07:08.171]                 local <- as.logical(local)
  [07:07:08.171]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.171]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.171]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.171]                   label = label, ...)
  [07:07:08.171]                 if (!future$lazy) 
  [07:07:08.171]                   future <- run(future)
  [07:07:08.171]                 invisible(future)
  [07:07:08.171]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.171]         }
  [07:07:08.171]         base::options(...future.oldOptions)
  [07:07:08.171]     })
  [07:07:08.171]     Sys.time
  [07:07:08.171]     if (base::is.na(NA)) {
  [07:07:08.171]     }
  [07:07:08.171]     else {
  [07:07:08.171]         base::sink(type = "output", split = FALSE)
  [07:07:08.171]         if (NA) {
  [07:07:08.171]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.171]         }
  [07:07:08.171]         else {
  [07:07:08.171]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.171]         }
  [07:07:08.171]         base::close(...future.stdout)
  [07:07:08.171]         ...future.stdout <- NULL
  [07:07:08.171]     }
  [07:07:08.171]     ...future.result$conditions <- ...future.conditions
  [07:07:08.171]     ...future.result
  [07:07:08.171] }
  [07:07:08.179] plan(): Setting new future strategy stack:
  [07:07:08.179] List of future strategies:
  [07:07:08.179] 1. sequential:
  [07:07:08.179]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.179]    - tweaked: FALSE
  [07:07:08.179]    - call: NULL
  [07:07:08.181] plan(): nbrOfWorkers() = 1
  [07:07:08.184] plan(): Setting new future strategy stack:
  [07:07:08.184] List of future strategies:
  [07:07:08.184] 1. sequential:
  [07:07:08.184]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.184]    - tweaked: FALSE
  [07:07:08.184]    - call: NULL
  [07:07:08.186] plan(): nbrOfWorkers() = 1
  [07:07:08.187] SequentialFuture started (and completed)
  [07:07:08.192] Packages needed by the future expression (n = 0): <none>
  [07:07:08.193] Packages needed by future strategies (n = 0): <none>
  [07:07:08.201] {
  [07:07:08.201]     {
  [07:07:08.201]         ...future.startTime <- base::Sys.time()
  [07:07:08.201]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.201]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.201]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.201]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.201]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.201]         {
  [07:07:08.201]             {
  [07:07:08.201]                 base::local({
  [07:07:08.201]                   has_future <- base::requireNamespace("future", 
  [07:07:08.201]                     quietly = TRUE)
  [07:07:08.201]                   version <- if (has_future) 
  [07:07:08.201]                     utils::packageVersion("future")
  [07:07:08.201]                   else NULL
  [07:07:08.201]                   if (!has_future || version < "1.8.0") {
  [07:07:08.201]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.201]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.201]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.201]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.201]                         "release", "version")], collapse = " "), 
  [07:07:08.201]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.201]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.201]                       info)
  [07:07:08.201]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.201]                     if (!has_future) {
  [07:07:08.201]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.201]                         info)
  [07:07:08.201]                     }
  [07:07:08.201]                     else {
  [07:07:08.201]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.201]                         info, version)
  [07:07:08.201]                     }
  [07:07:08.201]                     base::stop(msg)
  [07:07:08.201]                   }
  [07:07:08.201]                 })
  [07:07:08.201]             }
  [07:07:08.201]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.201]         }
  [07:07:08.201]     }
  [07:07:08.201]     if (base::is.na(NA)) {
  [07:07:08.201]     }
  [07:07:08.201]     else {
  [07:07:08.201]         if (NA) {
  [07:07:08.201]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.201]                 open = "w")
  [07:07:08.201]         }
  [07:07:08.201]         else {
  [07:07:08.201]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.201]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.201]         }
  [07:07:08.201]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.201]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.201]             base::sink(type = "output", split = FALSE)
  [07:07:08.201]             base::close(...future.stdout)
  [07:07:08.201]         }, add = TRUE)
  [07:07:08.201]     }
  [07:07:08.201]     ...future.frame <- base::sys.nframe()
  [07:07:08.201]     ...future.conditions <- base::list()
  [07:07:08.201]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.201]     ...future.result <- base::tryCatch({
  [07:07:08.201]         base::withCallingHandlers({
  [07:07:08.201]             ...future.value <- base::withVisible(base::local({
  [07:07:08.201]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.201]             }))
  [07:07:08.201]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.201]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.201]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.201]                 version = "1.8")
  [07:07:08.201]         }, condition = base::local({
  [07:07:08.201]             c <- base::c
  [07:07:08.201]             inherits <- base::inherits
  [07:07:08.201]             invokeRestart <- base::invokeRestart
  [07:07:08.201]             length <- base::length
  [07:07:08.201]             list <- base::list
  [07:07:08.201]             seq.int <- base::seq.int
  [07:07:08.201]             signalCondition <- base::signalCondition
  [07:07:08.201]             sys.calls <- base::sys.calls
  [07:07:08.201]             Sys.time <- base::Sys.time
  [07:07:08.201]             `[[` <- base::`[[`
  [07:07:08.201]             `+` <- base::`+`
  [07:07:08.201]             `<<-` <- base::`<<-`
  [07:07:08.201]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.201]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.201]                   3L)]
  [07:07:08.201]             }
  [07:07:08.201]             function(cond) {
  [07:07:08.201]                 if (inherits(cond, "error")) {
  [07:07:08.201]                   sessionInformation <- function() {
  [07:07:08.201]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.201]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.201]                       search = base::search(), system = base::Sys.info())
  [07:07:08.201]                   }
  [07:07:08.201]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.201]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.201]                     cond$call), session = sessionInformation(), 
  [07:07:08.201]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.201]                   signalCondition(cond)
  [07:07:08.201]                 }
  [07:07:08.201]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.201]                 ))) {
  [07:07:08.201]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.201]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.201]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.201]                   if (!signal) {
  [07:07:08.201]                     muffleCondition <- function (cond) 
  [07:07:08.201]                     {
  [07:07:08.201]                       inherits <- base::inherits
  [07:07:08.201]                       invokeRestart <- base::invokeRestart
  [07:07:08.201]                       muffled <- FALSE
  [07:07:08.201]                       if (inherits(cond, "message")) {
  [07:07:08.201]                         invokeRestart("muffleMessage")
  [07:07:08.201]                         muffled <- TRUE
  [07:07:08.201]                       }
  [07:07:08.201]                       else if (inherits(cond, "warning")) {
  [07:07:08.201]                         invokeRestart("muffleWarning")
  [07:07:08.201]                         muffled <- TRUE
  [07:07:08.201]                       }
  [07:07:08.201]                       else if (inherits(cond, "condition")) {
  [07:07:08.201]                         computeRestarts <- base::computeRestarts
  [07:07:08.201]                         grepl <- base::grepl
  [07:07:08.201]                         is.null <- base::is.null
  [07:07:08.201]                         restarts <- computeRestarts(cond)
  [07:07:08.201]                         for (restart in restarts) {
  [07:07:08.201]                           name <- restart$name
  [07:07:08.201]                           if (is.null(name)) 
  [07:07:08.201]                             next
  [07:07:08.201]                           if (!grepl("^muffle", name)) 
  [07:07:08.201]                             next
  [07:07:08.201]                           invokeRestart(restart)
  [07:07:08.201]                           muffled <- TRUE
  [07:07:08.201]                           break
  [07:07:08.201]                         }
  [07:07:08.201]                       }
  [07:07:08.201]                       invisible(muffled)
  [07:07:08.201]                     }
  [07:07:08.201]                     muffleCondition(cond)
  [07:07:08.201]                   }
  [07:07:08.201]                 }
  [07:07:08.201]             }
  [07:07:08.201]         }))
  [07:07:08.201]     }, error = function(ex) {
  [07:07:08.201]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.201]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.201]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.201]     }, finally = {
  [07:07:08.201]         {
  [07:07:08.201]             NULL
  [07:07:08.201]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.201]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.201]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.201]                 label = NULL, ...) 
  [07:07:08.201]             {
  [07:07:08.201]                 if (substitute) 
  [07:07:08.201]                   expr <- substitute(expr)
  [07:07:08.201]                 local <- as.logical(local)
  [07:07:08.201]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.201]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.201]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.201]                   label = label, ...)
  [07:07:08.201]                 if (!future$lazy) 
  [07:07:08.201]                   future <- run(future)
  [07:07:08.201]                 invisible(future)
  [07:07:08.201]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.201]         }
  [07:07:08.201]         base::options(...future.oldOptions)
  [07:07:08.201]     })
  [07:07:08.201]     Sys.time
  [07:07:08.201]     if (base::is.na(NA)) {
  [07:07:08.201]     }
  [07:07:08.201]     else {
  [07:07:08.201]         base::sink(type = "output", split = FALSE)
  [07:07:08.201]         if (NA) {
  [07:07:08.201]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.201]         }
  [07:07:08.201]         else {
  [07:07:08.201]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.201]         }
  [07:07:08.201]         base::close(...future.stdout)
  [07:07:08.201]         ...future.stdout <- NULL
  [07:07:08.201]     }
  [07:07:08.201]     ...future.result$conditions <- ...future.conditions
  [07:07:08.201]     ...future.result
  [07:07:08.201] }
  [07:07:08.209] plan(): Setting new future strategy stack:
  [07:07:08.210] List of future strategies:
  [07:07:08.210] 1. sequential:
  [07:07:08.210]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.210]    - tweaked: FALSE
  [07:07:08.210]    - call: NULL
  [07:07:08.212] plan(): nbrOfWorkers() = 1
  [07:07:08.213] plan(): Setting new future strategy stack:
  [07:07:08.214] List of future strategies:
  [07:07:08.214] 1. sequential:
  [07:07:08.214]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.214]    - tweaked: FALSE
  [07:07:08.214]    - call: NULL
  [07:07:08.216] plan(): nbrOfWorkers() = 1
  [07:07:08.217] SequentialFuture started (and completed)
  [07:07:08.219] plan(): Setting new future strategy stack:
  [07:07:08.219] List of future strategies:
  [07:07:08.219] 1. sequential:
  [07:07:08.219]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.219]    - tweaked: FALSE
  [07:07:08.219]    - call: NULL
  [07:07:08.221] plan(): nbrOfWorkers() = 1
  [07:07:08.222] SequentialFuture started (and completed)
  [07:07:08.225] Packages needed by the future expression (n = 0): <none>
  [07:07:08.226] Packages needed by future strategies (n = 0): <none>
  [07:07:08.238] {
  [07:07:08.238]     {
  [07:07:08.238]         ...future.startTime <- base::Sys.time()
  [07:07:08.238]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.238]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.238]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.238]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.238]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.238]         {
  [07:07:08.238]             {
  [07:07:08.238]                 base::local({
  [07:07:08.238]                   has_future <- base::requireNamespace("future", 
  [07:07:08.238]                     quietly = TRUE)
  [07:07:08.238]                   version <- if (has_future) 
  [07:07:08.238]                     utils::packageVersion("future")
  [07:07:08.238]                   else NULL
  [07:07:08.238]                   if (!has_future || version < "1.8.0") {
  [07:07:08.238]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.238]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.238]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.238]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.238]                         "release", "version")], collapse = " "), 
  [07:07:08.238]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.238]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.238]                       info)
  [07:07:08.238]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.238]                     if (!has_future) {
  [07:07:08.238]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.238]                         info)
  [07:07:08.238]                     }
  [07:07:08.238]                     else {
  [07:07:08.238]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.238]                         info, version)
  [07:07:08.238]                     }
  [07:07:08.238]                     base::stop(msg)
  [07:07:08.238]                   }
  [07:07:08.238]                 })
  [07:07:08.238]             }
  [07:07:08.238]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.238]         }
  [07:07:08.238]     }
  [07:07:08.238]     if (base::is.na(NA)) {
  [07:07:08.238]     }
  [07:07:08.238]     else {
  [07:07:08.238]         if (NA) {
  [07:07:08.238]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.238]                 open = "w")
  [07:07:08.238]         }
  [07:07:08.238]         else {
  [07:07:08.238]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.238]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.238]         }
  [07:07:08.238]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.238]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.238]             base::sink(type = "output", split = FALSE)
  [07:07:08.238]             base::close(...future.stdout)
  [07:07:08.238]         }, add = TRUE)
  [07:07:08.238]     }
  [07:07:08.238]     ...future.frame <- base::sys.nframe()
  [07:07:08.238]     ...future.conditions <- base::list()
  [07:07:08.238]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.238]     ...future.result <- base::tryCatch({
  [07:07:08.238]         base::withCallingHandlers({
  [07:07:08.238]             ...future.value <- base::withVisible(base::local({
  [07:07:08.238]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.238]             }))
  [07:07:08.238]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.238]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.238]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.238]                 version = "1.8")
  [07:07:08.238]         }, condition = base::local({
  [07:07:08.238]             c <- base::c
  [07:07:08.238]             inherits <- base::inherits
  [07:07:08.238]             invokeRestart <- base::invokeRestart
  [07:07:08.238]             length <- base::length
  [07:07:08.238]             list <- base::list
  [07:07:08.238]             seq.int <- base::seq.int
  [07:07:08.238]             signalCondition <- base::signalCondition
  [07:07:08.238]             sys.calls <- base::sys.calls
  [07:07:08.238]             Sys.time <- base::Sys.time
  [07:07:08.238]             `[[` <- base::`[[`
  [07:07:08.238]             `+` <- base::`+`
  [07:07:08.238]             `<<-` <- base::`<<-`
  [07:07:08.238]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.238]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.238]                   3L)]
  [07:07:08.238]             }
  [07:07:08.238]             function(cond) {
  [07:07:08.238]                 if (inherits(cond, "error")) {
  [07:07:08.238]                   sessionInformation <- function() {
  [07:07:08.238]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.238]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.238]                       search = base::search(), system = base::Sys.info())
  [07:07:08.238]                   }
  [07:07:08.238]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.238]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.238]                     cond$call), session = sessionInformation(), 
  [07:07:08.238]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.238]                   signalCondition(cond)
  [07:07:08.238]                 }
  [07:07:08.238]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.238]                 ))) {
  [07:07:08.238]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.238]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.238]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.238]                   if (!signal) {
  [07:07:08.238]                     muffleCondition <- function (cond) 
  [07:07:08.238]                     {
  [07:07:08.238]                       inherits <- base::inherits
  [07:07:08.238]                       invokeRestart <- base::invokeRestart
  [07:07:08.238]                       muffled <- FALSE
  [07:07:08.238]                       if (inherits(cond, "message")) {
  [07:07:08.238]                         invokeRestart("muffleMessage")
  [07:07:08.238]                         muffled <- TRUE
  [07:07:08.238]                       }
  [07:07:08.238]                       else if (inherits(cond, "warning")) {
  [07:07:08.238]                         invokeRestart("muffleWarning")
  [07:07:08.238]                         muffled <- TRUE
  [07:07:08.238]                       }
  [07:07:08.238]                       else if (inherits(cond, "condition")) {
  [07:07:08.238]                         computeRestarts <- base::computeRestarts
  [07:07:08.238]                         grepl <- base::grepl
  [07:07:08.238]                         is.null <- base::is.null
  [07:07:08.238]                         restarts <- computeRestarts(cond)
  [07:07:08.238]                         for (restart in restarts) {
  [07:07:08.238]                           name <- restart$name
  [07:07:08.238]                           if (is.null(name)) 
  [07:07:08.238]                             next
  [07:07:08.238]                           if (!grepl("^muffle", name)) 
  [07:07:08.238]                             next
  [07:07:08.238]                           invokeRestart(restart)
  [07:07:08.238]                           muffled <- TRUE
  [07:07:08.238]                           break
  [07:07:08.238]                         }
  [07:07:08.238]                       }
  [07:07:08.238]                       invisible(muffled)
  [07:07:08.238]                     }
  [07:07:08.238]                     muffleCondition(cond)
  [07:07:08.238]                   }
  [07:07:08.238]                 }
  [07:07:08.238]             }
  [07:07:08.238]         }))
  [07:07:08.238]     }, error = function(ex) {
  [07:07:08.238]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.238]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.238]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.238]     }, finally = {
  [07:07:08.238]         {
  [07:07:08.238]             NULL
  [07:07:08.238]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.238]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.238]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.238]                 label = NULL, ...) 
  [07:07:08.238]             {
  [07:07:08.238]                 if (substitute) 
  [07:07:08.238]                   expr <- substitute(expr)
  [07:07:08.238]                 local <- as.logical(local)
  [07:07:08.238]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.238]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.238]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.238]                   label = label, ...)
  [07:07:08.238]                 if (!future$lazy) 
  [07:07:08.238]                   future <- run(future)
  [07:07:08.238]                 invisible(future)
  [07:07:08.238]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.238]         }
  [07:07:08.238]         base::options(...future.oldOptions)
  [07:07:08.238]     })
  [07:07:08.238]     Sys.time
  [07:07:08.238]     if (base::is.na(NA)) {
  [07:07:08.238]     }
  [07:07:08.238]     else {
  [07:07:08.238]         base::sink(type = "output", split = FALSE)
  [07:07:08.238]         if (NA) {
  [07:07:08.238]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.238]         }
  [07:07:08.238]         else {
  [07:07:08.238]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.238]         }
  [07:07:08.238]         base::close(...future.stdout)
  [07:07:08.238]         ...future.stdout <- NULL
  [07:07:08.238]     }
  [07:07:08.238]     ...future.result$conditions <- ...future.conditions
  [07:07:08.238]     ...future.result
  [07:07:08.238] }
  [07:07:08.246] plan(): Setting new future strategy stack:
  [07:07:08.246] List of future strategies:
  [07:07:08.246] 1. sequential:
  [07:07:08.246]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.246]    - tweaked: FALSE
  [07:07:08.246]    - call: NULL
  [07:07:08.248] plan(): nbrOfWorkers() = 1
  [07:07:08.250] plan(): Setting new future strategy stack:
  [07:07:08.251] List of future strategies:
  [07:07:08.251] 1. sequential:
  [07:07:08.251]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.251]    - tweaked: FALSE
  [07:07:08.251]    - call: NULL
  [07:07:08.252] plan(): nbrOfWorkers() = 1
  [07:07:08.253] SequentialFuture started (and completed)
  [07:07:08.255] plan(): Setting new future strategy stack:
  [07:07:08.255] List of future strategies:
  [07:07:08.255] 1. sequential:
  [07:07:08.255]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.255]    - tweaked: FALSE
  [07:07:08.255]    - call: plan(sequential)
  [07:07:08.257] plan(): nbrOfWorkers() = 1
  [07:07:08.257] 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]])
  [07:07:08.261] Packages needed by the future expression (n = 0): <none>
  [07:07:08.262] Packages needed by future strategies (n = 0): <none>
  [07:07:08.270] {
  [07:07:08.270]     {
  [07:07:08.270]         ...future.startTime <- base::Sys.time()
  [07:07:08.270]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.270]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.270]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.270]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.270]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.270]         {
  [07:07:08.270]             {
  [07:07:08.270]                 base::local({
  [07:07:08.270]                   has_future <- base::requireNamespace("future", 
  [07:07:08.270]                     quietly = TRUE)
  [07:07:08.270]                   version <- if (has_future) 
  [07:07:08.270]                     utils::packageVersion("future")
  [07:07:08.270]                   else NULL
  [07:07:08.270]                   if (!has_future || version < "1.8.0") {
  [07:07:08.270]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.270]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.270]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.270]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.270]                         "release", "version")], collapse = " "), 
  [07:07:08.270]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.270]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.270]                       info)
  [07:07:08.270]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.270]                     if (!has_future) {
  [07:07:08.270]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.270]                         info)
  [07:07:08.270]                     }
  [07:07:08.270]                     else {
  [07:07:08.270]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.270]                         info, version)
  [07:07:08.270]                     }
  [07:07:08.270]                     base::stop(msg)
  [07:07:08.270]                   }
  [07:07:08.270]                 })
  [07:07:08.270]             }
  [07:07:08.270]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.270]         }
  [07:07:08.270]     }
  [07:07:08.270]     if (base::is.na(NA)) {
  [07:07:08.270]     }
  [07:07:08.270]     else {
  [07:07:08.270]         if (NA) {
  [07:07:08.270]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.270]                 open = "w")
  [07:07:08.270]         }
  [07:07:08.270]         else {
  [07:07:08.270]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.270]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.270]         }
  [07:07:08.270]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.270]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.270]             base::sink(type = "output", split = FALSE)
  [07:07:08.270]             base::close(...future.stdout)
  [07:07:08.270]         }, add = TRUE)
  [07:07:08.270]     }
  [07:07:08.270]     ...future.frame <- base::sys.nframe()
  [07:07:08.270]     ...future.conditions <- base::list()
  [07:07:08.270]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.270]     ...future.result <- base::tryCatch({
  [07:07:08.270]         base::withCallingHandlers({
  [07:07:08.270]             ...future.value <- base::withVisible(base::local({
  [07:07:08.270]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.270]             }))
  [07:07:08.270]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.270]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.270]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.270]                 version = "1.8")
  [07:07:08.270]         }, condition = base::local({
  [07:07:08.270]             c <- base::c
  [07:07:08.270]             inherits <- base::inherits
  [07:07:08.270]             invokeRestart <- base::invokeRestart
  [07:07:08.270]             length <- base::length
  [07:07:08.270]             list <- base::list
  [07:07:08.270]             seq.int <- base::seq.int
  [07:07:08.270]             signalCondition <- base::signalCondition
  [07:07:08.270]             sys.calls <- base::sys.calls
  [07:07:08.270]             Sys.time <- base::Sys.time
  [07:07:08.270]             `[[` <- base::`[[`
  [07:07:08.270]             `+` <- base::`+`
  [07:07:08.270]             `<<-` <- base::`<<-`
  [07:07:08.270]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.270]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.270]                   3L)]
  [07:07:08.270]             }
  [07:07:08.270]             function(cond) {
  [07:07:08.270]                 if (inherits(cond, "error")) {
  [07:07:08.270]                   sessionInformation <- function() {
  [07:07:08.270]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.270]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.270]                       search = base::search(), system = base::Sys.info())
  [07:07:08.270]                   }
  [07:07:08.270]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.270]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.270]                     cond$call), session = sessionInformation(), 
  [07:07:08.270]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.270]                   signalCondition(cond)
  [07:07:08.270]                 }
  [07:07:08.270]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.270]                 ))) {
  [07:07:08.270]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.270]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.270]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.270]                   if (!signal) {
  [07:07:08.270]                     muffleCondition <- function (cond) 
  [07:07:08.270]                     {
  [07:07:08.270]                       inherits <- base::inherits
  [07:07:08.270]                       invokeRestart <- base::invokeRestart
  [07:07:08.270]                       muffled <- FALSE
  [07:07:08.270]                       if (inherits(cond, "message")) {
  [07:07:08.270]                         invokeRestart("muffleMessage")
  [07:07:08.270]                         muffled <- TRUE
  [07:07:08.270]                       }
  [07:07:08.270]                       else if (inherits(cond, "warning")) {
  [07:07:08.270]                         invokeRestart("muffleWarning")
  [07:07:08.270]                         muffled <- TRUE
  [07:07:08.270]                       }
  [07:07:08.270]                       else if (inherits(cond, "condition")) {
  [07:07:08.270]                         computeRestarts <- base::computeRestarts
  [07:07:08.270]                         grepl <- base::grepl
  [07:07:08.270]                         is.null <- base::is.null
  [07:07:08.270]                         restarts <- computeRestarts(cond)
  [07:07:08.270]                         for (restart in restarts) {
  [07:07:08.270]                           name <- restart$name
  [07:07:08.270]                           if (is.null(name)) 
  [07:07:08.270]                             next
  [07:07:08.270]                           if (!grepl("^muffle", name)) 
  [07:07:08.270]                             next
  [07:07:08.270]                           invokeRestart(restart)
  [07:07:08.270]                           muffled <- TRUE
  [07:07:08.270]                           break
  [07:07:08.270]                         }
  [07:07:08.270]                       }
  [07:07:08.270]                       invisible(muffled)
  [07:07:08.270]                     }
  [07:07:08.270]                     muffleCondition(cond)
  [07:07:08.270]                   }
  [07:07:08.270]                 }
  [07:07:08.270]             }
  [07:07:08.270]         }))
  [07:07:08.270]     }, error = function(ex) {
  [07:07:08.270]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.270]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.270]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.270]     }, finally = {
  [07:07:08.270]         {
  [07:07:08.270]             NULL
  [07:07:08.270]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.270]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.270]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.270]                 label = NULL, ...) 
  [07:07:08.270]             {
  [07:07:08.270]                 if (substitute) 
  [07:07:08.270]                   expr <- substitute(expr)
  [07:07:08.270]                 local <- as.logical(local)
  [07:07:08.270]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.270]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.270]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.270]                   label = label, ...)
  [07:07:08.270]                 if (!future$lazy) 
  [07:07:08.270]                   future <- run(future)
  [07:07:08.270]                 invisible(future)
  [07:07:08.270]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.270]         }
  [07:07:08.270]         base::options(...future.oldOptions)
  [07:07:08.270]     })
  [07:07:08.270]     Sys.time
  [07:07:08.270]     if (base::is.na(NA)) {
  [07:07:08.270]     }
  [07:07:08.270]     else {
  [07:07:08.270]         base::sink(type = "output", split = FALSE)
  [07:07:08.270]         if (NA) {
  [07:07:08.270]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.270]         }
  [07:07:08.270]         else {
  [07:07:08.270]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.270]         }
  [07:07:08.270]         base::close(...future.stdout)
  [07:07:08.270]         ...future.stdout <- NULL
  [07:07:08.270]     }
  [07:07:08.270]     ...future.result$conditions <- ...future.conditions
  [07:07:08.270]     ...future.result
  [07:07:08.270] }
  [07:07:08.278] plan(): Setting new future strategy stack:
  [07:07:08.278] List of future strategies:
  [07:07:08.278] 1. sequential:
  [07:07:08.278]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.278]    - tweaked: FALSE
  [07:07:08.278]    - call: NULL
  [07:07:08.280] plan(): nbrOfWorkers() = 1
  [07:07:08.283] Packages needed by the future expression (n = 0): <none>
  [07:07:08.284] Packages needed by future strategies (n = 0): <none>
  [07:07:08.292] {
  [07:07:08.292]     {
  [07:07:08.292]         ...future.startTime <- base::Sys.time()
  [07:07:08.292]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.292]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.292]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.292]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.292]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.292]         {
  [07:07:08.292]             {
  [07:07:08.292]                 base::local({
  [07:07:08.292]                   has_future <- base::requireNamespace("future", 
  [07:07:08.292]                     quietly = TRUE)
  [07:07:08.292]                   version <- if (has_future) 
  [07:07:08.292]                     utils::packageVersion("future")
  [07:07:08.292]                   else NULL
  [07:07:08.292]                   if (!has_future || version < "1.8.0") {
  [07:07:08.292]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.292]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.292]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.292]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.292]                         "release", "version")], collapse = " "), 
  [07:07:08.292]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.292]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.292]                       info)
  [07:07:08.292]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.292]                     if (!has_future) {
  [07:07:08.292]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.292]                         info)
  [07:07:08.292]                     }
  [07:07:08.292]                     else {
  [07:07:08.292]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.292]                         info, version)
  [07:07:08.292]                     }
  [07:07:08.292]                     base::stop(msg)
  [07:07:08.292]                   }
  [07:07:08.292]                 })
  [07:07:08.292]             }
  [07:07:08.292]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.292]         }
  [07:07:08.292]     }
  [07:07:08.292]     if (base::is.na(NA)) {
  [07:07:08.292]     }
  [07:07:08.292]     else {
  [07:07:08.292]         if (NA) {
  [07:07:08.292]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.292]                 open = "w")
  [07:07:08.292]         }
  [07:07:08.292]         else {
  [07:07:08.292]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.292]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.292]         }
  [07:07:08.292]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.292]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.292]             base::sink(type = "output", split = FALSE)
  [07:07:08.292]             base::close(...future.stdout)
  [07:07:08.292]         }, add = TRUE)
  [07:07:08.292]     }
  [07:07:08.292]     ...future.frame <- base::sys.nframe()
  [07:07:08.292]     ...future.conditions <- base::list()
  [07:07:08.292]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.292]     ...future.result <- base::tryCatch({
  [07:07:08.292]         base::withCallingHandlers({
  [07:07:08.292]             ...future.value <- base::withVisible(base::local({
  [07:07:08.292]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.292]             }))
  [07:07:08.292]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.292]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.292]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.292]                 version = "1.8")
  [07:07:08.292]         }, condition = base::local({
  [07:07:08.292]             c <- base::c
  [07:07:08.292]             inherits <- base::inherits
  [07:07:08.292]             invokeRestart <- base::invokeRestart
  [07:07:08.292]             length <- base::length
  [07:07:08.292]             list <- base::list
  [07:07:08.292]             seq.int <- base::seq.int
  [07:07:08.292]             signalCondition <- base::signalCondition
  [07:07:08.292]             sys.calls <- base::sys.calls
  [07:07:08.292]             Sys.time <- base::Sys.time
  [07:07:08.292]             `[[` <- base::`[[`
  [07:07:08.292]             `+` <- base::`+`
  [07:07:08.292]             `<<-` <- base::`<<-`
  [07:07:08.292]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.292]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.292]                   3L)]
  [07:07:08.292]             }
  [07:07:08.292]             function(cond) {
  [07:07:08.292]                 if (inherits(cond, "error")) {
  [07:07:08.292]                   sessionInformation <- function() {
  [07:07:08.292]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.292]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.292]                       search = base::search(), system = base::Sys.info())
  [07:07:08.292]                   }
  [07:07:08.292]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.292]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.292]                     cond$call), session = sessionInformation(), 
  [07:07:08.292]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.292]                   signalCondition(cond)
  [07:07:08.292]                 }
  [07:07:08.292]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.292]                 ))) {
  [07:07:08.292]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.292]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.292]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.292]                   if (!signal) {
  [07:07:08.292]                     muffleCondition <- function (cond) 
  [07:07:08.292]                     {
  [07:07:08.292]                       inherits <- base::inherits
  [07:07:08.292]                       invokeRestart <- base::invokeRestart
  [07:07:08.292]                       muffled <- FALSE
  [07:07:08.292]                       if (inherits(cond, "message")) {
  [07:07:08.292]                         invokeRestart("muffleMessage")
  [07:07:08.292]                         muffled <- TRUE
  [07:07:08.292]                       }
  [07:07:08.292]                       else if (inherits(cond, "warning")) {
  [07:07:08.292]                         invokeRestart("muffleWarning")
  [07:07:08.292]                         muffled <- TRUE
  [07:07:08.292]                       }
  [07:07:08.292]                       else if (inherits(cond, "condition")) {
  [07:07:08.292]                         computeRestarts <- base::computeRestarts
  [07:07:08.292]                         grepl <- base::grepl
  [07:07:08.292]                         is.null <- base::is.null
  [07:07:08.292]                         restarts <- computeRestarts(cond)
  [07:07:08.292]                         for (restart in restarts) {
  [07:07:08.292]                           name <- restart$name
  [07:07:08.292]                           if (is.null(name)) 
  [07:07:08.292]                             next
  [07:07:08.292]                           if (!grepl("^muffle", name)) 
  [07:07:08.292]                             next
  [07:07:08.292]                           invokeRestart(restart)
  [07:07:08.292]                           muffled <- TRUE
  [07:07:08.292]                           break
  [07:07:08.292]                         }
  [07:07:08.292]                       }
  [07:07:08.292]                       invisible(muffled)
  [07:07:08.292]                     }
  [07:07:08.292]                     muffleCondition(cond)
  [07:07:08.292]                   }
  [07:07:08.292]                 }
  [07:07:08.292]             }
  [07:07:08.292]         }))
  [07:07:08.292]     }, error = function(ex) {
  [07:07:08.292]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.292]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.292]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.292]     }, finally = {
  [07:07:08.292]         {
  [07:07:08.292]             NULL
  [07:07:08.292]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.292]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.292]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.292]                 label = NULL, ...) 
  [07:07:08.292]             {
  [07:07:08.292]                 if (substitute) 
  [07:07:08.292]                   expr <- substitute(expr)
  [07:07:08.292]                 local <- as.logical(local)
  [07:07:08.292]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.292]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.292]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.292]                   label = label, ...)
  [07:07:08.292]                 if (!future$lazy) 
  [07:07:08.292]                   future <- run(future)
  [07:07:08.292]                 invisible(future)
  [07:07:08.292]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.292]         }
  [07:07:08.292]         base::options(...future.oldOptions)
  [07:07:08.292]     })
  [07:07:08.292]     Sys.time
  [07:07:08.292]     if (base::is.na(NA)) {
  [07:07:08.292]     }
  [07:07:08.292]     else {
  [07:07:08.292]         base::sink(type = "output", split = FALSE)
  [07:07:08.292]         if (NA) {
  [07:07:08.292]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.292]         }
  [07:07:08.292]         else {
  [07:07:08.292]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.292]         }
  [07:07:08.292]         base::close(...future.stdout)
  [07:07:08.292]         ...future.stdout <- NULL
  [07:07:08.292]     }
  [07:07:08.292]     ...future.result$conditions <- ...future.conditions
  [07:07:08.292]     ...future.result
  [07:07:08.292] }
  [07:07:08.300] plan(): Setting new future strategy stack:
  [07:07:08.301] List of future strategies:
  [07:07:08.301] 1. sequential:
  [07:07:08.301]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.301]    - tweaked: FALSE
  [07:07:08.301]    - call: NULL
  [07:07:08.303] plan(): nbrOfWorkers() = 1
  [07:07:08.306] Packages needed by the future expression (n = 0): <none>
  [07:07:08.307] Packages needed by future strategies (n = 0): <none>
  [07:07:08.316] {
  [07:07:08.316]     {
  [07:07:08.316]         ...future.startTime <- base::Sys.time()
  [07:07:08.316]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.316]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.316]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.316]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.316]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.316]         {
  [07:07:08.316]             {
  [07:07:08.316]                 base::local({
  [07:07:08.316]                   has_future <- base::requireNamespace("future", 
  [07:07:08.316]                     quietly = TRUE)
  [07:07:08.316]                   version <- if (has_future) 
  [07:07:08.316]                     utils::packageVersion("future")
  [07:07:08.316]                   else NULL
  [07:07:08.316]                   if (!has_future || version < "1.8.0") {
  [07:07:08.316]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.316]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.316]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.316]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.316]                         "release", "version")], collapse = " "), 
  [07:07:08.316]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.316]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.316]                       info)
  [07:07:08.316]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.316]                     if (!has_future) {
  [07:07:08.316]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.316]                         info)
  [07:07:08.316]                     }
  [07:07:08.316]                     else {
  [07:07:08.316]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.316]                         info, version)
  [07:07:08.316]                     }
  [07:07:08.316]                     base::stop(msg)
  [07:07:08.316]                   }
  [07:07:08.316]                 })
  [07:07:08.316]             }
  [07:07:08.316]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.316]         }
  [07:07:08.316]     }
  [07:07:08.316]     if (base::is.na(NA)) {
  [07:07:08.316]     }
  [07:07:08.316]     else {
  [07:07:08.316]         if (NA) {
  [07:07:08.316]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.316]                 open = "w")
  [07:07:08.316]         }
  [07:07:08.316]         else {
  [07:07:08.316]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.316]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.316]         }
  [07:07:08.316]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.316]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.316]             base::sink(type = "output", split = FALSE)
  [07:07:08.316]             base::close(...future.stdout)
  [07:07:08.316]         }, add = TRUE)
  [07:07:08.316]     }
  [07:07:08.316]     ...future.frame <- base::sys.nframe()
  [07:07:08.316]     ...future.conditions <- base::list()
  [07:07:08.316]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.316]     ...future.result <- base::tryCatch({
  [07:07:08.316]         base::withCallingHandlers({
  [07:07:08.316]             ...future.value <- base::withVisible(base::local({
  [07:07:08.316]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.316]             }))
  [07:07:08.316]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.316]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.316]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.316]                 version = "1.8")
  [07:07:08.316]         }, condition = base::local({
  [07:07:08.316]             c <- base::c
  [07:07:08.316]             inherits <- base::inherits
  [07:07:08.316]             invokeRestart <- base::invokeRestart
  [07:07:08.316]             length <- base::length
  [07:07:08.316]             list <- base::list
  [07:07:08.316]             seq.int <- base::seq.int
  [07:07:08.316]             signalCondition <- base::signalCondition
  [07:07:08.316]             sys.calls <- base::sys.calls
  [07:07:08.316]             Sys.time <- base::Sys.time
  [07:07:08.316]             `[[` <- base::`[[`
  [07:07:08.316]             `+` <- base::`+`
  [07:07:08.316]             `<<-` <- base::`<<-`
  [07:07:08.316]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.316]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.316]                   3L)]
  [07:07:08.316]             }
  [07:07:08.316]             function(cond) {
  [07:07:08.316]                 if (inherits(cond, "error")) {
  [07:07:08.316]                   sessionInformation <- function() {
  [07:07:08.316]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.316]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.316]                       search = base::search(), system = base::Sys.info())
  [07:07:08.316]                   }
  [07:07:08.316]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.316]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.316]                     cond$call), session = sessionInformation(), 
  [07:07:08.316]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.316]                   signalCondition(cond)
  [07:07:08.316]                 }
  [07:07:08.316]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.316]                 ))) {
  [07:07:08.316]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.316]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.316]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.316]                   if (!signal) {
  [07:07:08.316]                     muffleCondition <- function (cond) 
  [07:07:08.316]                     {
  [07:07:08.316]                       inherits <- base::inherits
  [07:07:08.316]                       invokeRestart <- base::invokeRestart
  [07:07:08.316]                       muffled <- FALSE
  [07:07:08.316]                       if (inherits(cond, "message")) {
  [07:07:08.316]                         invokeRestart("muffleMessage")
  [07:07:08.316]                         muffled <- TRUE
  [07:07:08.316]                       }
  [07:07:08.316]                       else if (inherits(cond, "warning")) {
  [07:07:08.316]                         invokeRestart("muffleWarning")
  [07:07:08.316]                         muffled <- TRUE
  [07:07:08.316]                       }
  [07:07:08.316]                       else if (inherits(cond, "condition")) {
  [07:07:08.316]                         computeRestarts <- base::computeRestarts
  [07:07:08.316]                         grepl <- base::grepl
  [07:07:08.316]                         is.null <- base::is.null
  [07:07:08.316]                         restarts <- computeRestarts(cond)
  [07:07:08.316]                         for (restart in restarts) {
  [07:07:08.316]                           name <- restart$name
  [07:07:08.316]                           if (is.null(name)) 
  [07:07:08.316]                             next
  [07:07:08.316]                           if (!grepl("^muffle", name)) 
  [07:07:08.316]                             next
  [07:07:08.316]                           invokeRestart(restart)
  [07:07:08.316]                           muffled <- TRUE
  [07:07:08.316]                           break
  [07:07:08.316]                         }
  [07:07:08.316]                       }
  [07:07:08.316]                       invisible(muffled)
  [07:07:08.316]                     }
  [07:07:08.316]                     muffleCondition(cond)
  [07:07:08.316]                   }
  [07:07:08.316]                 }
  [07:07:08.316]             }
  [07:07:08.316]         }))
  [07:07:08.316]     }, error = function(ex) {
  [07:07:08.316]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.316]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.316]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.316]     }, finally = {
  [07:07:08.316]         {
  [07:07:08.316]             NULL
  [07:07:08.316]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.316]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.316]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.316]                 label = NULL, ...) 
  [07:07:08.316]             {
  [07:07:08.316]                 if (substitute) 
  [07:07:08.316]                   expr <- substitute(expr)
  [07:07:08.316]                 local <- as.logical(local)
  [07:07:08.316]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.316]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.316]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.316]                   label = label, ...)
  [07:07:08.316]                 if (!future$lazy) 
  [07:07:08.316]                   future <- run(future)
  [07:07:08.316]                 invisible(future)
  [07:07:08.316]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.316]         }
  [07:07:08.316]         base::options(...future.oldOptions)
  [07:07:08.316]     })
  [07:07:08.316]     Sys.time
  [07:07:08.316]     if (base::is.na(NA)) {
  [07:07:08.316]     }
  [07:07:08.316]     else {
  [07:07:08.316]         base::sink(type = "output", split = FALSE)
  [07:07:08.316]         if (NA) {
  [07:07:08.316]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.316]         }
  [07:07:08.316]         else {
  [07:07:08.316]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.316]         }
  [07:07:08.316]         base::close(...future.stdout)
  [07:07:08.316]         ...future.stdout <- NULL
  [07:07:08.316]     }
  [07:07:08.316]     ...future.result$conditions <- ...future.conditions
  [07:07:08.316]     ...future.result
  [07:07:08.316] }
  [07:07:08.323] plan(): Setting new future strategy stack:
  [07:07:08.324] List of future strategies:
  [07:07:08.324] 1. sequential:
  [07:07:08.324]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.324]    - tweaked: FALSE
  [07:07:08.324]    - call: NULL
  [07:07:08.326] plan(): nbrOfWorkers() = 1
  [07:07:08.330] Packages needed by the future expression (n = 0): <none>
  [07:07:08.331] Packages needed by future strategies (n = 0): <none>
  [07:07:08.339] {
  [07:07:08.339]     {
  [07:07:08.339]         ...future.startTime <- base::Sys.time()
  [07:07:08.339]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.339]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.339]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.339]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.339]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.339]         {
  [07:07:08.339]             {
  [07:07:08.339]                 base::local({
  [07:07:08.339]                   has_future <- base::requireNamespace("future", 
  [07:07:08.339]                     quietly = TRUE)
  [07:07:08.339]                   version <- if (has_future) 
  [07:07:08.339]                     utils::packageVersion("future")
  [07:07:08.339]                   else NULL
  [07:07:08.339]                   if (!has_future || version < "1.8.0") {
  [07:07:08.339]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.339]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.339]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.339]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.339]                         "release", "version")], collapse = " "), 
  [07:07:08.339]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.339]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.339]                       info)
  [07:07:08.339]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.339]                     if (!has_future) {
  [07:07:08.339]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.339]                         info)
  [07:07:08.339]                     }
  [07:07:08.339]                     else {
  [07:07:08.339]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.339]                         info, version)
  [07:07:08.339]                     }
  [07:07:08.339]                     base::stop(msg)
  [07:07:08.339]                   }
  [07:07:08.339]                 })
  [07:07:08.339]             }
  [07:07:08.339]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.339]         }
  [07:07:08.339]     }
  [07:07:08.339]     if (base::is.na(NA)) {
  [07:07:08.339]     }
  [07:07:08.339]     else {
  [07:07:08.339]         if (NA) {
  [07:07:08.339]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.339]                 open = "w")
  [07:07:08.339]         }
  [07:07:08.339]         else {
  [07:07:08.339]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.339]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.339]         }
  [07:07:08.339]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.339]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.339]             base::sink(type = "output", split = FALSE)
  [07:07:08.339]             base::close(...future.stdout)
  [07:07:08.339]         }, add = TRUE)
  [07:07:08.339]     }
  [07:07:08.339]     ...future.frame <- base::sys.nframe()
  [07:07:08.339]     ...future.conditions <- base::list()
  [07:07:08.339]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.339]     ...future.result <- base::tryCatch({
  [07:07:08.339]         base::withCallingHandlers({
  [07:07:08.339]             ...future.value <- base::withVisible(base::local({
  [07:07:08.339]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.339]             }))
  [07:07:08.339]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.339]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.339]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.339]                 version = "1.8")
  [07:07:08.339]         }, condition = base::local({
  [07:07:08.339]             c <- base::c
  [07:07:08.339]             inherits <- base::inherits
  [07:07:08.339]             invokeRestart <- base::invokeRestart
  [07:07:08.339]             length <- base::length
  [07:07:08.339]             list <- base::list
  [07:07:08.339]             seq.int <- base::seq.int
  [07:07:08.339]             signalCondition <- base::signalCondition
  [07:07:08.339]             sys.calls <- base::sys.calls
  [07:07:08.339]             Sys.time <- base::Sys.time
  [07:07:08.339]             `[[` <- base::`[[`
  [07:07:08.339]             `+` <- base::`+`
  [07:07:08.339]             `<<-` <- base::`<<-`
  [07:07:08.339]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.339]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.339]                   3L)]
  [07:07:08.339]             }
  [07:07:08.339]             function(cond) {
  [07:07:08.339]                 if (inherits(cond, "error")) {
  [07:07:08.339]                   sessionInformation <- function() {
  [07:07:08.339]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.339]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.339]                       search = base::search(), system = base::Sys.info())
  [07:07:08.339]                   }
  [07:07:08.339]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.339]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.339]                     cond$call), session = sessionInformation(), 
  [07:07:08.339]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.339]                   signalCondition(cond)
  [07:07:08.339]                 }
  [07:07:08.339]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.339]                 ))) {
  [07:07:08.339]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.339]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.339]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.339]                   if (!signal) {
  [07:07:08.339]                     muffleCondition <- function (cond) 
  [07:07:08.339]                     {
  [07:07:08.339]                       inherits <- base::inherits
  [07:07:08.339]                       invokeRestart <- base::invokeRestart
  [07:07:08.339]                       muffled <- FALSE
  [07:07:08.339]                       if (inherits(cond, "message")) {
  [07:07:08.339]                         invokeRestart("muffleMessage")
  [07:07:08.339]                         muffled <- TRUE
  [07:07:08.339]                       }
  [07:07:08.339]                       else if (inherits(cond, "warning")) {
  [07:07:08.339]                         invokeRestart("muffleWarning")
  [07:07:08.339]                         muffled <- TRUE
  [07:07:08.339]                       }
  [07:07:08.339]                       else if (inherits(cond, "condition")) {
  [07:07:08.339]                         computeRestarts <- base::computeRestarts
  [07:07:08.339]                         grepl <- base::grepl
  [07:07:08.339]                         is.null <- base::is.null
  [07:07:08.339]                         restarts <- computeRestarts(cond)
  [07:07:08.339]                         for (restart in restarts) {
  [07:07:08.339]                           name <- restart$name
  [07:07:08.339]                           if (is.null(name)) 
  [07:07:08.339]                             next
  [07:07:08.339]                           if (!grepl("^muffle", name)) 
  [07:07:08.339]                             next
  [07:07:08.339]                           invokeRestart(restart)
  [07:07:08.339]                           muffled <- TRUE
  [07:07:08.339]                           break
  [07:07:08.339]                         }
  [07:07:08.339]                       }
  [07:07:08.339]                       invisible(muffled)
  [07:07:08.339]                     }
  [07:07:08.339]                     muffleCondition(cond)
  [07:07:08.339]                   }
  [07:07:08.339]                 }
  [07:07:08.339]             }
  [07:07:08.339]         }))
  [07:07:08.339]     }, error = function(ex) {
  [07:07:08.339]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.339]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.339]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.339]     }, finally = {
  [07:07:08.339]         {
  [07:07:08.339]             NULL
  [07:07:08.339]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.339]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.339]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.339]                 label = NULL, ...) 
  [07:07:08.339]             {
  [07:07:08.339]                 if (substitute) 
  [07:07:08.339]                   expr <- substitute(expr)
  [07:07:08.339]                 local <- as.logical(local)
  [07:07:08.339]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.339]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.339]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.339]                   label = label, ...)
  [07:07:08.339]                 if (!future$lazy) 
  [07:07:08.339]                   future <- run(future)
  [07:07:08.339]                 invisible(future)
  [07:07:08.339]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.339]         }
  [07:07:08.339]         base::options(...future.oldOptions)
  [07:07:08.339]     })
  [07:07:08.339]     Sys.time
  [07:07:08.339]     if (base::is.na(NA)) {
  [07:07:08.339]     }
  [07:07:08.339]     else {
  [07:07:08.339]         base::sink(type = "output", split = FALSE)
  [07:07:08.339]         if (NA) {
  [07:07:08.339]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.339]         }
  [07:07:08.339]         else {
  [07:07:08.339]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.339]         }
  [07:07:08.339]         base::close(...future.stdout)
  [07:07:08.339]         ...future.stdout <- NULL
  [07:07:08.339]     }
  [07:07:08.339]     ...future.result$conditions <- ...future.conditions
  [07:07:08.339]     ...future.result
  [07:07:08.339] }
  [07:07:08.347] plan(): Setting new future strategy stack:
  [07:07:08.349] List of future strategies:
  [07:07:08.349] 1. sequential:
  [07:07:08.349]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.349]    - tweaked: FALSE
  [07:07:08.349]    - call: NULL
  [07:07:08.351] plan(): nbrOfWorkers() = 1
  [07:07:08.355] Packages needed by the future expression (n = 0): <none>
  [07:07:08.360] Packages needed by future strategies (n = 0): <none>
  [07:07:08.368] {
  [07:07:08.368]     {
  [07:07:08.368]         ...future.startTime <- base::Sys.time()
  [07:07:08.368]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.368]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.368]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.368]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.368]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.368]         {
  [07:07:08.368]             {
  [07:07:08.368]                 base::local({
  [07:07:08.368]                   has_future <- base::requireNamespace("future", 
  [07:07:08.368]                     quietly = TRUE)
  [07:07:08.368]                   version <- if (has_future) 
  [07:07:08.368]                     utils::packageVersion("future")
  [07:07:08.368]                   else NULL
  [07:07:08.368]                   if (!has_future || version < "1.8.0") {
  [07:07:08.368]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.368]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.368]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.368]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.368]                         "release", "version")], collapse = " "), 
  [07:07:08.368]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.368]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.368]                       info)
  [07:07:08.368]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.368]                     if (!has_future) {
  [07:07:08.368]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.368]                         info)
  [07:07:08.368]                     }
  [07:07:08.368]                     else {
  [07:07:08.368]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.368]                         info, version)
  [07:07:08.368]                     }
  [07:07:08.368]                     base::stop(msg)
  [07:07:08.368]                   }
  [07:07:08.368]                 })
  [07:07:08.368]             }
  [07:07:08.368]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.368]         }
  [07:07:08.368]     }
  [07:07:08.368]     if (base::is.na(NA)) {
  [07:07:08.368]     }
  [07:07:08.368]     else {
  [07:07:08.368]         if (NA) {
  [07:07:08.368]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.368]                 open = "w")
  [07:07:08.368]         }
  [07:07:08.368]         else {
  [07:07:08.368]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.368]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.368]         }
  [07:07:08.368]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.368]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.368]             base::sink(type = "output", split = FALSE)
  [07:07:08.368]             base::close(...future.stdout)
  [07:07:08.368]         }, add = TRUE)
  [07:07:08.368]     }
  [07:07:08.368]     ...future.frame <- base::sys.nframe()
  [07:07:08.368]     ...future.conditions <- base::list()
  [07:07:08.368]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.368]     ...future.result <- base::tryCatch({
  [07:07:08.368]         base::withCallingHandlers({
  [07:07:08.368]             ...future.value <- base::withVisible(base::local({
  [07:07:08.368]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.368]             }))
  [07:07:08.368]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.368]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.368]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.368]                 version = "1.8")
  [07:07:08.368]         }, condition = base::local({
  [07:07:08.368]             c <- base::c
  [07:07:08.368]             inherits <- base::inherits
  [07:07:08.368]             invokeRestart <- base::invokeRestart
  [07:07:08.368]             length <- base::length
  [07:07:08.368]             list <- base::list
  [07:07:08.368]             seq.int <- base::seq.int
  [07:07:08.368]             signalCondition <- base::signalCondition
  [07:07:08.368]             sys.calls <- base::sys.calls
  [07:07:08.368]             Sys.time <- base::Sys.time
  [07:07:08.368]             `[[` <- base::`[[`
  [07:07:08.368]             `+` <- base::`+`
  [07:07:08.368]             `<<-` <- base::`<<-`
  [07:07:08.368]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.368]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.368]                   3L)]
  [07:07:08.368]             }
  [07:07:08.368]             function(cond) {
  [07:07:08.368]                 if (inherits(cond, "error")) {
  [07:07:08.368]                   sessionInformation <- function() {
  [07:07:08.368]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.368]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.368]                       search = base::search(), system = base::Sys.info())
  [07:07:08.368]                   }
  [07:07:08.368]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.368]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.368]                     cond$call), session = sessionInformation(), 
  [07:07:08.368]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.368]                   signalCondition(cond)
  [07:07:08.368]                 }
  [07:07:08.368]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.368]                 ))) {
  [07:07:08.368]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.368]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.368]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.368]                   if (!signal) {
  [07:07:08.368]                     muffleCondition <- function (cond) 
  [07:07:08.368]                     {
  [07:07:08.368]                       inherits <- base::inherits
  [07:07:08.368]                       invokeRestart <- base::invokeRestart
  [07:07:08.368]                       muffled <- FALSE
  [07:07:08.368]                       if (inherits(cond, "message")) {
  [07:07:08.368]                         invokeRestart("muffleMessage")
  [07:07:08.368]                         muffled <- TRUE
  [07:07:08.368]                       }
  [07:07:08.368]                       else if (inherits(cond, "warning")) {
  [07:07:08.368]                         invokeRestart("muffleWarning")
  [07:07:08.368]                         muffled <- TRUE
  [07:07:08.368]                       }
  [07:07:08.368]                       else if (inherits(cond, "condition")) {
  [07:07:08.368]                         computeRestarts <- base::computeRestarts
  [07:07:08.368]                         grepl <- base::grepl
  [07:07:08.368]                         is.null <- base::is.null
  [07:07:08.368]                         restarts <- computeRestarts(cond)
  [07:07:08.368]                         for (restart in restarts) {
  [07:07:08.368]                           name <- restart$name
  [07:07:08.368]                           if (is.null(name)) 
  [07:07:08.368]                             next
  [07:07:08.368]                           if (!grepl("^muffle", name)) 
  [07:07:08.368]                             next
  [07:07:08.368]                           invokeRestart(restart)
  [07:07:08.368]                           muffled <- TRUE
  [07:07:08.368]                           break
  [07:07:08.368]                         }
  [07:07:08.368]                       }
  [07:07:08.368]                       invisible(muffled)
  [07:07:08.368]                     }
  [07:07:08.368]                     muffleCondition(cond)
  [07:07:08.368]                   }
  [07:07:08.368]                 }
  [07:07:08.368]             }
  [07:07:08.368]         }))
  [07:07:08.368]     }, error = function(ex) {
  [07:07:08.368]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.368]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.368]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.368]     }, finally = {
  [07:07:08.368]         {
  [07:07:08.368]             NULL
  [07:07:08.368]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.368]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.368]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.368]                 label = NULL, ...) 
  [07:07:08.368]             {
  [07:07:08.368]                 if (substitute) 
  [07:07:08.368]                   expr <- substitute(expr)
  [07:07:08.368]                 local <- as.logical(local)
  [07:07:08.368]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.368]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.368]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.368]                   label = label, ...)
  [07:07:08.368]                 if (!future$lazy) 
  [07:07:08.368]                   future <- run(future)
  [07:07:08.368]                 invisible(future)
  [07:07:08.368]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.368]         }
  [07:07:08.368]         base::options(...future.oldOptions)
  [07:07:08.368]     })
  [07:07:08.368]     Sys.time
  [07:07:08.368]     if (base::is.na(NA)) {
  [07:07:08.368]     }
  [07:07:08.368]     else {
  [07:07:08.368]         base::sink(type = "output", split = FALSE)
  [07:07:08.368]         if (NA) {
  [07:07:08.368]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.368]         }
  [07:07:08.368]         else {
  [07:07:08.368]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.368]         }
  [07:07:08.368]         base::close(...future.stdout)
  [07:07:08.368]         ...future.stdout <- NULL
  [07:07:08.368]     }
  [07:07:08.368]     ...future.result$conditions <- ...future.conditions
  [07:07:08.368]     ...future.result
  [07:07:08.368] }
  [07:07:08.376] plan(): Setting new future strategy stack:
  [07:07:08.378] List of future strategies:
  [07:07:08.378] 1. sequential:
  [07:07:08.378]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.378]    - tweaked: FALSE
  [07:07:08.378]    - call: NULL
  [07:07:08.380] plan(): nbrOfWorkers() = 1
  [07:07:08.385] Packages needed by the future expression (n = 0): <none>
  [07:07:08.386] Packages needed by future strategies (n = 0): <none>
  [07:07:08.395] {
  [07:07:08.395]     {
  [07:07:08.395]         ...future.startTime <- base::Sys.time()
  [07:07:08.395]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.395]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.395]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.395]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.395]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.395]         {
  [07:07:08.395]             {
  [07:07:08.395]                 base::local({
  [07:07:08.395]                   has_future <- base::requireNamespace("future", 
  [07:07:08.395]                     quietly = TRUE)
  [07:07:08.395]                   version <- if (has_future) 
  [07:07:08.395]                     utils::packageVersion("future")
  [07:07:08.395]                   else NULL
  [07:07:08.395]                   if (!has_future || version < "1.8.0") {
  [07:07:08.395]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.395]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.395]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.395]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.395]                         "release", "version")], collapse = " "), 
  [07:07:08.395]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.395]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.395]                       info)
  [07:07:08.395]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.395]                     if (!has_future) {
  [07:07:08.395]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.395]                         info)
  [07:07:08.395]                     }
  [07:07:08.395]                     else {
  [07:07:08.395]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.395]                         info, version)
  [07:07:08.395]                     }
  [07:07:08.395]                     base::stop(msg)
  [07:07:08.395]                   }
  [07:07:08.395]                 })
  [07:07:08.395]             }
  [07:07:08.395]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.395]         }
  [07:07:08.395]     }
  [07:07:08.395]     if (base::is.na(NA)) {
  [07:07:08.395]     }
  [07:07:08.395]     else {
  [07:07:08.395]         if (NA) {
  [07:07:08.395]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.395]                 open = "w")
  [07:07:08.395]         }
  [07:07:08.395]         else {
  [07:07:08.395]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.395]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.395]         }
  [07:07:08.395]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.395]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.395]             base::sink(type = "output", split = FALSE)
  [07:07:08.395]             base::close(...future.stdout)
  [07:07:08.395]         }, add = TRUE)
  [07:07:08.395]     }
  [07:07:08.395]     ...future.frame <- base::sys.nframe()
  [07:07:08.395]     ...future.conditions <- base::list()
  [07:07:08.395]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.395]     ...future.result <- base::tryCatch({
  [07:07:08.395]         base::withCallingHandlers({
  [07:07:08.395]             ...future.value <- base::withVisible(base::local({
  [07:07:08.395]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.395]             }))
  [07:07:08.395]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.395]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.395]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.395]                 version = "1.8")
  [07:07:08.395]         }, condition = base::local({
  [07:07:08.395]             c <- base::c
  [07:07:08.395]             inherits <- base::inherits
  [07:07:08.395]             invokeRestart <- base::invokeRestart
  [07:07:08.395]             length <- base::length
  [07:07:08.395]             list <- base::list
  [07:07:08.395]             seq.int <- base::seq.int
  [07:07:08.395]             signalCondition <- base::signalCondition
  [07:07:08.395]             sys.calls <- base::sys.calls
  [07:07:08.395]             Sys.time <- base::Sys.time
  [07:07:08.395]             `[[` <- base::`[[`
  [07:07:08.395]             `+` <- base::`+`
  [07:07:08.395]             `<<-` <- base::`<<-`
  [07:07:08.395]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.395]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.395]                   3L)]
  [07:07:08.395]             }
  [07:07:08.395]             function(cond) {
  [07:07:08.395]                 if (inherits(cond, "error")) {
  [07:07:08.395]                   sessionInformation <- function() {
  [07:07:08.395]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.395]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.395]                       search = base::search(), system = base::Sys.info())
  [07:07:08.395]                   }
  [07:07:08.395]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.395]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.395]                     cond$call), session = sessionInformation(), 
  [07:07:08.395]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.395]                   signalCondition(cond)
  [07:07:08.395]                 }
  [07:07:08.395]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.395]                 ))) {
  [07:07:08.395]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.395]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.395]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.395]                   if (!signal) {
  [07:07:08.395]                     muffleCondition <- function (cond) 
  [07:07:08.395]                     {
  [07:07:08.395]                       inherits <- base::inherits
  [07:07:08.395]                       invokeRestart <- base::invokeRestart
  [07:07:08.395]                       muffled <- FALSE
  [07:07:08.395]                       if (inherits(cond, "message")) {
  [07:07:08.395]                         invokeRestart("muffleMessage")
  [07:07:08.395]                         muffled <- TRUE
  [07:07:08.395]                       }
  [07:07:08.395]                       else if (inherits(cond, "warning")) {
  [07:07:08.395]                         invokeRestart("muffleWarning")
  [07:07:08.395]                         muffled <- TRUE
  [07:07:08.395]                       }
  [07:07:08.395]                       else if (inherits(cond, "condition")) {
  [07:07:08.395]                         computeRestarts <- base::computeRestarts
  [07:07:08.395]                         grepl <- base::grepl
  [07:07:08.395]                         is.null <- base::is.null
  [07:07:08.395]                         restarts <- computeRestarts(cond)
  [07:07:08.395]                         for (restart in restarts) {
  [07:07:08.395]                           name <- restart$name
  [07:07:08.395]                           if (is.null(name)) 
  [07:07:08.395]                             next
  [07:07:08.395]                           if (!grepl("^muffle", name)) 
  [07:07:08.395]                             next
  [07:07:08.395]                           invokeRestart(restart)
  [07:07:08.395]                           muffled <- TRUE
  [07:07:08.395]                           break
  [07:07:08.395]                         }
  [07:07:08.395]                       }
  [07:07:08.395]                       invisible(muffled)
  [07:07:08.395]                     }
  [07:07:08.395]                     muffleCondition(cond)
  [07:07:08.395]                   }
  [07:07:08.395]                 }
  [07:07:08.395]             }
  [07:07:08.395]         }))
  [07:07:08.395]     }, error = function(ex) {
  [07:07:08.395]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.395]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.395]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.395]     }, finally = {
  [07:07:08.395]         {
  [07:07:08.395]             NULL
  [07:07:08.395]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.395]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.395]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.395]                 label = NULL, ...) 
  [07:07:08.395]             {
  [07:07:08.395]                 if (substitute) 
  [07:07:08.395]                   expr <- substitute(expr)
  [07:07:08.395]                 local <- as.logical(local)
  [07:07:08.395]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.395]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.395]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.395]                   label = label, ...)
  [07:07:08.395]                 if (!future$lazy) 
  [07:07:08.395]                   future <- run(future)
  [07:07:08.395]                 invisible(future)
  [07:07:08.395]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.395]         }
  [07:07:08.395]         base::options(...future.oldOptions)
  [07:07:08.395]     })
  [07:07:08.395]     Sys.time
  [07:07:08.395]     if (base::is.na(NA)) {
  [07:07:08.395]     }
  [07:07:08.395]     else {
  [07:07:08.395]         base::sink(type = "output", split = FALSE)
  [07:07:08.395]         if (NA) {
  [07:07:08.395]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.395]         }
  [07:07:08.395]         else {
  [07:07:08.395]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.395]         }
  [07:07:08.395]         base::close(...future.stdout)
  [07:07:08.395]         ...future.stdout <- NULL
  [07:07:08.395]     }
  [07:07:08.395]     ...future.result$conditions <- ...future.conditions
  [07:07:08.395]     ...future.result
  [07:07:08.395] }
  [07:07:08.404] plan(): Setting new future strategy stack:
  [07:07:08.405] List of future strategies:
  [07:07:08.405] 1. sequential:
  [07:07:08.405]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.405]    - tweaked: FALSE
  [07:07:08.405]    - call: NULL
  [07:07:08.408] plan(): nbrOfWorkers() = 1
  [07:07:08.412] Packages needed by the future expression (n = 0): <none>
  [07:07:08.414] Packages needed by future strategies (n = 0): <none>
  [07:07:08.423] {
  [07:07:08.423]     {
  [07:07:08.423]         ...future.startTime <- base::Sys.time()
  [07:07:08.423]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.423]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.423]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.423]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.423]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.423]         {
  [07:07:08.423]             {
  [07:07:08.423]                 base::local({
  [07:07:08.423]                   has_future <- base::requireNamespace("future", 
  [07:07:08.423]                     quietly = TRUE)
  [07:07:08.423]                   version <- if (has_future) 
  [07:07:08.423]                     utils::packageVersion("future")
  [07:07:08.423]                   else NULL
  [07:07:08.423]                   if (!has_future || version < "1.8.0") {
  [07:07:08.423]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.423]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.423]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.423]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.423]                         "release", "version")], collapse = " "), 
  [07:07:08.423]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.423]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.423]                       info)
  [07:07:08.423]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.423]                     if (!has_future) {
  [07:07:08.423]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.423]                         info)
  [07:07:08.423]                     }
  [07:07:08.423]                     else {
  [07:07:08.423]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.423]                         info, version)
  [07:07:08.423]                     }
  [07:07:08.423]                     base::stop(msg)
  [07:07:08.423]                   }
  [07:07:08.423]                 })
  [07:07:08.423]             }
  [07:07:08.423]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.423]         }
  [07:07:08.423]     }
  [07:07:08.423]     if (base::is.na(NA)) {
  [07:07:08.423]     }
  [07:07:08.423]     else {
  [07:07:08.423]         if (NA) {
  [07:07:08.423]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.423]                 open = "w")
  [07:07:08.423]         }
  [07:07:08.423]         else {
  [07:07:08.423]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.423]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.423]         }
  [07:07:08.423]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.423]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.423]             base::sink(type = "output", split = FALSE)
  [07:07:08.423]             base::close(...future.stdout)
  [07:07:08.423]         }, add = TRUE)
  [07:07:08.423]     }
  [07:07:08.423]     ...future.frame <- base::sys.nframe()
  [07:07:08.423]     ...future.conditions <- base::list()
  [07:07:08.423]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.423]     ...future.result <- base::tryCatch({
  [07:07:08.423]         base::withCallingHandlers({
  [07:07:08.423]             ...future.value <- base::withVisible(base::local({
  [07:07:08.423]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.423]             }))
  [07:07:08.423]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.423]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.423]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.423]                 version = "1.8")
  [07:07:08.423]         }, condition = base::local({
  [07:07:08.423]             c <- base::c
  [07:07:08.423]             inherits <- base::inherits
  [07:07:08.423]             invokeRestart <- base::invokeRestart
  [07:07:08.423]             length <- base::length
  [07:07:08.423]             list <- base::list
  [07:07:08.423]             seq.int <- base::seq.int
  [07:07:08.423]             signalCondition <- base::signalCondition
  [07:07:08.423]             sys.calls <- base::sys.calls
  [07:07:08.423]             Sys.time <- base::Sys.time
  [07:07:08.423]             `[[` <- base::`[[`
  [07:07:08.423]             `+` <- base::`+`
  [07:07:08.423]             `<<-` <- base::`<<-`
  [07:07:08.423]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.423]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.423]                   3L)]
  [07:07:08.423]             }
  [07:07:08.423]             function(cond) {
  [07:07:08.423]                 if (inherits(cond, "error")) {
  [07:07:08.423]                   sessionInformation <- function() {
  [07:07:08.423]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.423]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.423]                       search = base::search(), system = base::Sys.info())
  [07:07:08.423]                   }
  [07:07:08.423]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.423]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.423]                     cond$call), session = sessionInformation(), 
  [07:07:08.423]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.423]                   signalCondition(cond)
  [07:07:08.423]                 }
  [07:07:08.423]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.423]                 ))) {
  [07:07:08.423]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.423]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.423]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.423]                   if (!signal) {
  [07:07:08.423]                     muffleCondition <- function (cond) 
  [07:07:08.423]                     {
  [07:07:08.423]                       inherits <- base::inherits
  [07:07:08.423]                       invokeRestart <- base::invokeRestart
  [07:07:08.423]                       muffled <- FALSE
  [07:07:08.423]                       if (inherits(cond, "message")) {
  [07:07:08.423]                         invokeRestart("muffleMessage")
  [07:07:08.423]                         muffled <- TRUE
  [07:07:08.423]                       }
  [07:07:08.423]                       else if (inherits(cond, "warning")) {
  [07:07:08.423]                         invokeRestart("muffleWarning")
  [07:07:08.423]                         muffled <- TRUE
  [07:07:08.423]                       }
  [07:07:08.423]                       else if (inherits(cond, "condition")) {
  [07:07:08.423]                         computeRestarts <- base::computeRestarts
  [07:07:08.423]                         grepl <- base::grepl
  [07:07:08.423]                         is.null <- base::is.null
  [07:07:08.423]                         restarts <- computeRestarts(cond)
  [07:07:08.423]                         for (restart in restarts) {
  [07:07:08.423]                           name <- restart$name
  [07:07:08.423]                           if (is.null(name)) 
  [07:07:08.423]                             next
  [07:07:08.423]                           if (!grepl("^muffle", name)) 
  [07:07:08.423]                             next
  [07:07:08.423]                           invokeRestart(restart)
  [07:07:08.423]                           muffled <- TRUE
  [07:07:08.423]                           break
  [07:07:08.423]                         }
  [07:07:08.423]                       }
  [07:07:08.423]                       invisible(muffled)
  [07:07:08.423]                     }
  [07:07:08.423]                     muffleCondition(cond)
  [07:07:08.423]                   }
  [07:07:08.423]                 }
  [07:07:08.423]             }
  [07:07:08.423]         }))
  [07:07:08.423]     }, error = function(ex) {
  [07:07:08.423]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.423]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.423]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.423]     }, finally = {
  [07:07:08.423]         {
  [07:07:08.423]             NULL
  [07:07:08.423]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.423]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.423]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.423]                 label = NULL, ...) 
  [07:07:08.423]             {
  [07:07:08.423]                 if (substitute) 
  [07:07:08.423]                   expr <- substitute(expr)
  [07:07:08.423]                 local <- as.logical(local)
  [07:07:08.423]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.423]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.423]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.423]                   label = label, ...)
  [07:07:08.423]                 if (!future$lazy) 
  [07:07:08.423]                   future <- run(future)
  [07:07:08.423]                 invisible(future)
  [07:07:08.423]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.423]         }
  [07:07:08.423]         base::options(...future.oldOptions)
  [07:07:08.423]     })
  [07:07:08.423]     Sys.time
  [07:07:08.423]     if (base::is.na(NA)) {
  [07:07:08.423]     }
  [07:07:08.423]     else {
  [07:07:08.423]         base::sink(type = "output", split = FALSE)
  [07:07:08.423]         if (NA) {
  [07:07:08.423]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.423]         }
  [07:07:08.423]         else {
  [07:07:08.423]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.423]         }
  [07:07:08.423]         base::close(...future.stdout)
  [07:07:08.423]         ...future.stdout <- NULL
  [07:07:08.423]     }
  [07:07:08.423]     ...future.result$conditions <- ...future.conditions
  [07:07:08.423]     ...future.result
  [07:07:08.423] }
  [07:07:08.431] plan(): Setting new future strategy stack:
  [07:07:08.433] List of future strategies:
  [07:07:08.433] 1. sequential:
  [07:07:08.433]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.433]    - tweaked: FALSE
  [07:07:08.433]    - call: NULL
  [07:07:08.435] plan(): nbrOfWorkers() = 1
  [07:07:08.440] Packages needed by the future expression (n = 0): <none>
  [07:07:08.442] Packages needed by future strategies (n = 0): <none>
  [07:07:08.451] {
  [07:07:08.451]     {
  [07:07:08.451]         ...future.startTime <- base::Sys.time()
  [07:07:08.451]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.451]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.451]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.451]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.451]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.451]         {
  [07:07:08.451]             {
  [07:07:08.451]                 base::local({
  [07:07:08.451]                   has_future <- base::requireNamespace("future", 
  [07:07:08.451]                     quietly = TRUE)
  [07:07:08.451]                   version <- if (has_future) 
  [07:07:08.451]                     utils::packageVersion("future")
  [07:07:08.451]                   else NULL
  [07:07:08.451]                   if (!has_future || version < "1.8.0") {
  [07:07:08.451]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.451]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.451]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.451]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.451]                         "release", "version")], collapse = " "), 
  [07:07:08.451]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.451]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.451]                       info)
  [07:07:08.451]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.451]                     if (!has_future) {
  [07:07:08.451]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.451]                         info)
  [07:07:08.451]                     }
  [07:07:08.451]                     else {
  [07:07:08.451]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.451]                         info, version)
  [07:07:08.451]                     }
  [07:07:08.451]                     base::stop(msg)
  [07:07:08.451]                   }
  [07:07:08.451]                 })
  [07:07:08.451]             }
  [07:07:08.451]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.451]         }
  [07:07:08.451]     }
  [07:07:08.451]     if (base::is.na(NA)) {
  [07:07:08.451]     }
  [07:07:08.451]     else {
  [07:07:08.451]         if (NA) {
  [07:07:08.451]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.451]                 open = "w")
  [07:07:08.451]         }
  [07:07:08.451]         else {
  [07:07:08.451]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.451]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.451]         }
  [07:07:08.451]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.451]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.451]             base::sink(type = "output", split = FALSE)
  [07:07:08.451]             base::close(...future.stdout)
  [07:07:08.451]         }, add = TRUE)
  [07:07:08.451]     }
  [07:07:08.451]     ...future.frame <- base::sys.nframe()
  [07:07:08.451]     ...future.conditions <- base::list()
  [07:07:08.451]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.451]     ...future.result <- base::tryCatch({
  [07:07:08.451]         base::withCallingHandlers({
  [07:07:08.451]             ...future.value <- base::withVisible(base::local({
  [07:07:08.451]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.451]             }))
  [07:07:08.451]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.451]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.451]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.451]                 version = "1.8")
  [07:07:08.451]         }, condition = base::local({
  [07:07:08.451]             c <- base::c
  [07:07:08.451]             inherits <- base::inherits
  [07:07:08.451]             invokeRestart <- base::invokeRestart
  [07:07:08.451]             length <- base::length
  [07:07:08.451]             list <- base::list
  [07:07:08.451]             seq.int <- base::seq.int
  [07:07:08.451]             signalCondition <- base::signalCondition
  [07:07:08.451]             sys.calls <- base::sys.calls
  [07:07:08.451]             Sys.time <- base::Sys.time
  [07:07:08.451]             `[[` <- base::`[[`
  [07:07:08.451]             `+` <- base::`+`
  [07:07:08.451]             `<<-` <- base::`<<-`
  [07:07:08.451]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.451]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.451]                   3L)]
  [07:07:08.451]             }
  [07:07:08.451]             function(cond) {
  [07:07:08.451]                 if (inherits(cond, "error")) {
  [07:07:08.451]                   sessionInformation <- function() {
  [07:07:08.451]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.451]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.451]                       search = base::search(), system = base::Sys.info())
  [07:07:08.451]                   }
  [07:07:08.451]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.451]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.451]                     cond$call), session = sessionInformation(), 
  [07:07:08.451]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.451]                   signalCondition(cond)
  [07:07:08.451]                 }
  [07:07:08.451]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.451]                 ))) {
  [07:07:08.451]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.451]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.451]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.451]                   if (!signal) {
  [07:07:08.451]                     muffleCondition <- function (cond) 
  [07:07:08.451]                     {
  [07:07:08.451]                       inherits <- base::inherits
  [07:07:08.451]                       invokeRestart <- base::invokeRestart
  [07:07:08.451]                       muffled <- FALSE
  [07:07:08.451]                       if (inherits(cond, "message")) {
  [07:07:08.451]                         invokeRestart("muffleMessage")
  [07:07:08.451]                         muffled <- TRUE
  [07:07:08.451]                       }
  [07:07:08.451]                       else if (inherits(cond, "warning")) {
  [07:07:08.451]                         invokeRestart("muffleWarning")
  [07:07:08.451]                         muffled <- TRUE
  [07:07:08.451]                       }
  [07:07:08.451]                       else if (inherits(cond, "condition")) {
  [07:07:08.451]                         computeRestarts <- base::computeRestarts
  [07:07:08.451]                         grepl <- base::grepl
  [07:07:08.451]                         is.null <- base::is.null
  [07:07:08.451]                         restarts <- computeRestarts(cond)
  [07:07:08.451]                         for (restart in restarts) {
  [07:07:08.451]                           name <- restart$name
  [07:07:08.451]                           if (is.null(name)) 
  [07:07:08.451]                             next
  [07:07:08.451]                           if (!grepl("^muffle", name)) 
  [07:07:08.451]                             next
  [07:07:08.451]                           invokeRestart(restart)
  [07:07:08.451]                           muffled <- TRUE
  [07:07:08.451]                           break
  [07:07:08.451]                         }
  [07:07:08.451]                       }
  [07:07:08.451]                       invisible(muffled)
  [07:07:08.451]                     }
  [07:07:08.451]                     muffleCondition(cond)
  [07:07:08.451]                   }
  [07:07:08.451]                 }
  [07:07:08.451]             }
  [07:07:08.451]         }))
  [07:07:08.451]     }, error = function(ex) {
  [07:07:08.451]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.451]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.451]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.451]     }, finally = {
  [07:07:08.451]         {
  [07:07:08.451]             NULL
  [07:07:08.451]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.451]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.451]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.451]                 label = NULL, ...) 
  [07:07:08.451]             {
  [07:07:08.451]                 if (substitute) 
  [07:07:08.451]                   expr <- substitute(expr)
  [07:07:08.451]                 local <- as.logical(local)
  [07:07:08.451]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.451]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.451]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.451]                   label = label, ...)
  [07:07:08.451]                 if (!future$lazy) 
  [07:07:08.451]                   future <- run(future)
  [07:07:08.451]                 invisible(future)
  [07:07:08.451]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.451]         }
  [07:07:08.451]         base::options(...future.oldOptions)
  [07:07:08.451]     })
  [07:07:08.451]     Sys.time
  [07:07:08.451]     if (base::is.na(NA)) {
  [07:07:08.451]     }
  [07:07:08.451]     else {
  [07:07:08.451]         base::sink(type = "output", split = FALSE)
  [07:07:08.451]         if (NA) {
  [07:07:08.451]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.451]         }
  [07:07:08.451]         else {
  [07:07:08.451]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.451]         }
  [07:07:08.451]         base::close(...future.stdout)
  [07:07:08.451]         ...future.stdout <- NULL
  [07:07:08.451]     }
  [07:07:08.451]     ...future.result$conditions <- ...future.conditions
  [07:07:08.451]     ...future.result
  [07:07:08.451] }
  [07:07:08.460] plan(): Setting new future strategy stack:
  [07:07:08.462] List of future strategies:
  [07:07:08.462] 1. sequential:
  [07:07:08.462]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.462]    - tweaked: FALSE
  [07:07:08.462]    - call: NULL
  [07:07:08.465] plan(): nbrOfWorkers() = 1
  [07:07:08.470] Packages needed by the future expression (n = 0): <none>
  [07:07:08.473] Packages needed by future strategies (n = 0): <none>
  [07:07:08.482] {
  [07:07:08.482]     {
  [07:07:08.482]         ...future.startTime <- base::Sys.time()
  [07:07:08.482]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.482]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.482]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.482]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.482]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.482]         {
  [07:07:08.482]             {
  [07:07:08.482]                 base::local({
  [07:07:08.482]                   has_future <- base::requireNamespace("future", 
  [07:07:08.482]                     quietly = TRUE)
  [07:07:08.482]                   version <- if (has_future) 
  [07:07:08.482]                     utils::packageVersion("future")
  [07:07:08.482]                   else NULL
  [07:07:08.482]                   if (!has_future || version < "1.8.0") {
  [07:07:08.482]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.482]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.482]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.482]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.482]                         "release", "version")], collapse = " "), 
  [07:07:08.482]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.482]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.482]                       info)
  [07:07:08.482]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.482]                     if (!has_future) {
  [07:07:08.482]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.482]                         info)
  [07:07:08.482]                     }
  [07:07:08.482]                     else {
  [07:07:08.482]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.482]                         info, version)
  [07:07:08.482]                     }
  [07:07:08.482]                     base::stop(msg)
  [07:07:08.482]                   }
  [07:07:08.482]                 })
  [07:07:08.482]             }
  [07:07:08.482]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.482]         }
  [07:07:08.482]     }
  [07:07:08.482]     if (base::is.na(NA)) {
  [07:07:08.482]     }
  [07:07:08.482]     else {
  [07:07:08.482]         if (NA) {
  [07:07:08.482]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.482]                 open = "w")
  [07:07:08.482]         }
  [07:07:08.482]         else {
  [07:07:08.482]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.482]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.482]         }
  [07:07:08.482]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.482]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.482]             base::sink(type = "output", split = FALSE)
  [07:07:08.482]             base::close(...future.stdout)
  [07:07:08.482]         }, add = TRUE)
  [07:07:08.482]     }
  [07:07:08.482]     ...future.frame <- base::sys.nframe()
  [07:07:08.482]     ...future.conditions <- base::list()
  [07:07:08.482]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.482]     ...future.result <- base::tryCatch({
  [07:07:08.482]         base::withCallingHandlers({
  [07:07:08.482]             ...future.value <- base::withVisible(base::local({
  [07:07:08.482]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.482]             }))
  [07:07:08.482]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.482]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.482]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.482]                 version = "1.8")
  [07:07:08.482]         }, condition = base::local({
  [07:07:08.482]             c <- base::c
  [07:07:08.482]             inherits <- base::inherits
  [07:07:08.482]             invokeRestart <- base::invokeRestart
  [07:07:08.482]             length <- base::length
  [07:07:08.482]             list <- base::list
  [07:07:08.482]             seq.int <- base::seq.int
  [07:07:08.482]             signalCondition <- base::signalCondition
  [07:07:08.482]             sys.calls <- base::sys.calls
  [07:07:08.482]             Sys.time <- base::Sys.time
  [07:07:08.482]             `[[` <- base::`[[`
  [07:07:08.482]             `+` <- base::`+`
  [07:07:08.482]             `<<-` <- base::`<<-`
  [07:07:08.482]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.482]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.482]                   3L)]
  [07:07:08.482]             }
  [07:07:08.482]             function(cond) {
  [07:07:08.482]                 if (inherits(cond, "error")) {
  [07:07:08.482]                   sessionInformation <- function() {
  [07:07:08.482]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.482]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.482]                       search = base::search(), system = base::Sys.info())
  [07:07:08.482]                   }
  [07:07:08.482]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.482]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.482]                     cond$call), session = sessionInformation(), 
  [07:07:08.482]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.482]                   signalCondition(cond)
  [07:07:08.482]                 }
  [07:07:08.482]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.482]                 ))) {
  [07:07:08.482]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.482]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.482]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.482]                   if (!signal) {
  [07:07:08.482]                     muffleCondition <- function (cond) 
  [07:07:08.482]                     {
  [07:07:08.482]                       inherits <- base::inherits
  [07:07:08.482]                       invokeRestart <- base::invokeRestart
  [07:07:08.482]                       muffled <- FALSE
  [07:07:08.482]                       if (inherits(cond, "message")) {
  [07:07:08.482]                         invokeRestart("muffleMessage")
  [07:07:08.482]                         muffled <- TRUE
  [07:07:08.482]                       }
  [07:07:08.482]                       else if (inherits(cond, "warning")) {
  [07:07:08.482]                         invokeRestart("muffleWarning")
  [07:07:08.482]                         muffled <- TRUE
  [07:07:08.482]                       }
  [07:07:08.482]                       else if (inherits(cond, "condition")) {
  [07:07:08.482]                         computeRestarts <- base::computeRestarts
  [07:07:08.482]                         grepl <- base::grepl
  [07:07:08.482]                         is.null <- base::is.null
  [07:07:08.482]                         restarts <- computeRestarts(cond)
  [07:07:08.482]                         for (restart in restarts) {
  [07:07:08.482]                           name <- restart$name
  [07:07:08.482]                           if (is.null(name)) 
  [07:07:08.482]                             next
  [07:07:08.482]                           if (!grepl("^muffle", name)) 
  [07:07:08.482]                             next
  [07:07:08.482]                           invokeRestart(restart)
  [07:07:08.482]                           muffled <- TRUE
  [07:07:08.482]                           break
  [07:07:08.482]                         }
  [07:07:08.482]                       }
  [07:07:08.482]                       invisible(muffled)
  [07:07:08.482]                     }
  [07:07:08.482]                     muffleCondition(cond)
  [07:07:08.482]                   }
  [07:07:08.482]                 }
  [07:07:08.482]             }
  [07:07:08.482]         }))
  [07:07:08.482]     }, error = function(ex) {
  [07:07:08.482]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.482]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.482]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.482]     }, finally = {
  [07:07:08.482]         {
  [07:07:08.482]             NULL
  [07:07:08.482]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.482]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.482]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.482]                 label = NULL, ...) 
  [07:07:08.482]             {
  [07:07:08.482]                 if (substitute) 
  [07:07:08.482]                   expr <- substitute(expr)
  [07:07:08.482]                 local <- as.logical(local)
  [07:07:08.482]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.482]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.482]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.482]                   label = label, ...)
  [07:07:08.482]                 if (!future$lazy) 
  [07:07:08.482]                   future <- run(future)
  [07:07:08.482]                 invisible(future)
  [07:07:08.482]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.482]         }
  [07:07:08.482]         base::options(...future.oldOptions)
  [07:07:08.482]     })
  [07:07:08.482]     Sys.time
  [07:07:08.482]     if (base::is.na(NA)) {
  [07:07:08.482]     }
  [07:07:08.482]     else {
  [07:07:08.482]         base::sink(type = "output", split = FALSE)
  [07:07:08.482]         if (NA) {
  [07:07:08.482]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.482]         }
  [07:07:08.482]         else {
  [07:07:08.482]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.482]         }
  [07:07:08.482]         base::close(...future.stdout)
  [07:07:08.482]         ...future.stdout <- NULL
  [07:07:08.482]     }
  [07:07:08.482]     ...future.result$conditions <- ...future.conditions
  [07:07:08.482]     ...future.result
  [07:07:08.482] }
  [07:07:08.495] plan(): Setting new future strategy stack:
  [07:07:08.497] List of future strategies:
  [07:07:08.497] 1. sequential:
  [07:07:08.497]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.497]    - tweaked: FALSE
  [07:07:08.497]    - call: NULL
  [07:07:08.500] plan(): nbrOfWorkers() = 1
  [07:07:08.506] Packages needed by the future expression (n = 0): <none>
  [07:07:08.508] Packages needed by future strategies (n = 0): <none>
  [07:07:08.518] {
  [07:07:08.518]     {
  [07:07:08.518]         ...future.startTime <- base::Sys.time()
  [07:07:08.518]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.518]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.518]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.518]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.518]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.518]         {
  [07:07:08.518]             {
  [07:07:08.518]                 base::local({
  [07:07:08.518]                   has_future <- base::requireNamespace("future", 
  [07:07:08.518]                     quietly = TRUE)
  [07:07:08.518]                   version <- if (has_future) 
  [07:07:08.518]                     utils::packageVersion("future")
  [07:07:08.518]                   else NULL
  [07:07:08.518]                   if (!has_future || version < "1.8.0") {
  [07:07:08.518]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.518]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.518]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.518]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.518]                         "release", "version")], collapse = " "), 
  [07:07:08.518]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.518]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.518]                       info)
  [07:07:08.518]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.518]                     if (!has_future) {
  [07:07:08.518]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.518]                         info)
  [07:07:08.518]                     }
  [07:07:08.518]                     else {
  [07:07:08.518]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.518]                         info, version)
  [07:07:08.518]                     }
  [07:07:08.518]                     base::stop(msg)
  [07:07:08.518]                   }
  [07:07:08.518]                 })
  [07:07:08.518]             }
  [07:07:08.518]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.518]         }
  [07:07:08.518]     }
  [07:07:08.518]     if (base::is.na(NA)) {
  [07:07:08.518]     }
  [07:07:08.518]     else {
  [07:07:08.518]         if (NA) {
  [07:07:08.518]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.518]                 open = "w")
  [07:07:08.518]         }
  [07:07:08.518]         else {
  [07:07:08.518]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.518]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.518]         }
  [07:07:08.518]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.518]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.518]             base::sink(type = "output", split = FALSE)
  [07:07:08.518]             base::close(...future.stdout)
  [07:07:08.518]         }, add = TRUE)
  [07:07:08.518]     }
  [07:07:08.518]     ...future.frame <- base::sys.nframe()
  [07:07:08.518]     ...future.conditions <- base::list()
  [07:07:08.518]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.518]     ...future.result <- base::tryCatch({
  [07:07:08.518]         base::withCallingHandlers({
  [07:07:08.518]             ...future.value <- base::withVisible(base::local({
  [07:07:08.518]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.518]             }))
  [07:07:08.518]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.518]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.518]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.518]                 version = "1.8")
  [07:07:08.518]         }, condition = base::local({
  [07:07:08.518]             c <- base::c
  [07:07:08.518]             inherits <- base::inherits
  [07:07:08.518]             invokeRestart <- base::invokeRestart
  [07:07:08.518]             length <- base::length
  [07:07:08.518]             list <- base::list
  [07:07:08.518]             seq.int <- base::seq.int
  [07:07:08.518]             signalCondition <- base::signalCondition
  [07:07:08.518]             sys.calls <- base::sys.calls
  [07:07:08.518]             Sys.time <- base::Sys.time
  [07:07:08.518]             `[[` <- base::`[[`
  [07:07:08.518]             `+` <- base::`+`
  [07:07:08.518]             `<<-` <- base::`<<-`
  [07:07:08.518]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.518]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.518]                   3L)]
  [07:07:08.518]             }
  [07:07:08.518]             function(cond) {
  [07:07:08.518]                 if (inherits(cond, "error")) {
  [07:07:08.518]                   sessionInformation <- function() {
  [07:07:08.518]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.518]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.518]                       search = base::search(), system = base::Sys.info())
  [07:07:08.518]                   }
  [07:07:08.518]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.518]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.518]                     cond$call), session = sessionInformation(), 
  [07:07:08.518]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.518]                   signalCondition(cond)
  [07:07:08.518]                 }
  [07:07:08.518]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.518]                 ))) {
  [07:07:08.518]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.518]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.518]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.518]                   if (!signal) {
  [07:07:08.518]                     muffleCondition <- function (cond) 
  [07:07:08.518]                     {
  [07:07:08.518]                       inherits <- base::inherits
  [07:07:08.518]                       invokeRestart <- base::invokeRestart
  [07:07:08.518]                       muffled <- FALSE
  [07:07:08.518]                       if (inherits(cond, "message")) {
  [07:07:08.518]                         invokeRestart("muffleMessage")
  [07:07:08.518]                         muffled <- TRUE
  [07:07:08.518]                       }
  [07:07:08.518]                       else if (inherits(cond, "warning")) {
  [07:07:08.518]                         invokeRestart("muffleWarning")
  [07:07:08.518]                         muffled <- TRUE
  [07:07:08.518]                       }
  [07:07:08.518]                       else if (inherits(cond, "condition")) {
  [07:07:08.518]                         computeRestarts <- base::computeRestarts
  [07:07:08.518]                         grepl <- base::grepl
  [07:07:08.518]                         is.null <- base::is.null
  [07:07:08.518]                         restarts <- computeRestarts(cond)
  [07:07:08.518]                         for (restart in restarts) {
  [07:07:08.518]                           name <- restart$name
  [07:07:08.518]                           if (is.null(name)) 
  [07:07:08.518]                             next
  [07:07:08.518]                           if (!grepl("^muffle", name)) 
  [07:07:08.518]                             next
  [07:07:08.518]                           invokeRestart(restart)
  [07:07:08.518]                           muffled <- TRUE
  [07:07:08.518]                           break
  [07:07:08.518]                         }
  [07:07:08.518]                       }
  [07:07:08.518]                       invisible(muffled)
  [07:07:08.518]                     }
  [07:07:08.518]                     muffleCondition(cond)
  [07:07:08.518]                   }
  [07:07:08.518]                 }
  [07:07:08.518]             }
  [07:07:08.518]         }))
  [07:07:08.518]     }, error = function(ex) {
  [07:07:08.518]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.518]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.518]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.518]     }, finally = {
  [07:07:08.518]         {
  [07:07:08.518]             NULL
  [07:07:08.518]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.518]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.518]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.518]                 label = NULL, ...) 
  [07:07:08.518]             {
  [07:07:08.518]                 if (substitute) 
  [07:07:08.518]                   expr <- substitute(expr)
  [07:07:08.518]                 local <- as.logical(local)
  [07:07:08.518]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.518]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.518]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.518]                   label = label, ...)
  [07:07:08.518]                 if (!future$lazy) 
  [07:07:08.518]                   future <- run(future)
  [07:07:08.518]                 invisible(future)
  [07:07:08.518]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.518]         }
  [07:07:08.518]         base::options(...future.oldOptions)
  [07:07:08.518]     })
  [07:07:08.518]     Sys.time
  [07:07:08.518]     if (base::is.na(NA)) {
  [07:07:08.518]     }
  [07:07:08.518]     else {
  [07:07:08.518]         base::sink(type = "output", split = FALSE)
  [07:07:08.518]         if (NA) {
  [07:07:08.518]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.518]         }
  [07:07:08.518]         else {
  [07:07:08.518]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.518]         }
  [07:07:08.518]         base::close(...future.stdout)
  [07:07:08.518]         ...future.stdout <- NULL
  [07:07:08.518]     }
  [07:07:08.518]     ...future.result$conditions <- ...future.conditions
  [07:07:08.518]     ...future.result
  [07:07:08.518] }
  [07:07:08.528] plan(): Setting new future strategy stack:
  [07:07:08.530] List of future strategies:
  [07:07:08.530] 1. sequential:
  [07:07:08.530]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.530]    - tweaked: FALSE
  [07:07:08.530]    - call: NULL
  [07:07:08.533] plan(): nbrOfWorkers() = 1
  [07:07:08.538] Packages needed by the future expression (n = 0): <none>
  [07:07:08.541] Packages needed by future strategies (n = 0): <none>
  [07:07:08.551] {
  [07:07:08.551]     {
  [07:07:08.551]         ...future.startTime <- base::Sys.time()
  [07:07:08.551]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.551]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.551]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.551]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.551]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.551]         {
  [07:07:08.551]             {
  [07:07:08.551]                 base::local({
  [07:07:08.551]                   has_future <- base::requireNamespace("future", 
  [07:07:08.551]                     quietly = TRUE)
  [07:07:08.551]                   version <- if (has_future) 
  [07:07:08.551]                     utils::packageVersion("future")
  [07:07:08.551]                   else NULL
  [07:07:08.551]                   if (!has_future || version < "1.8.0") {
  [07:07:08.551]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.551]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.551]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.551]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.551]                         "release", "version")], collapse = " "), 
  [07:07:08.551]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.551]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.551]                       info)
  [07:07:08.551]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.551]                     if (!has_future) {
  [07:07:08.551]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.551]                         info)
  [07:07:08.551]                     }
  [07:07:08.551]                     else {
  [07:07:08.551]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.551]                         info, version)
  [07:07:08.551]                     }
  [07:07:08.551]                     base::stop(msg)
  [07:07:08.551]                   }
  [07:07:08.551]                 })
  [07:07:08.551]             }
  [07:07:08.551]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.551]         }
  [07:07:08.551]     }
  [07:07:08.551]     if (base::is.na(NA)) {
  [07:07:08.551]     }
  [07:07:08.551]     else {
  [07:07:08.551]         if (NA) {
  [07:07:08.551]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.551]                 open = "w")
  [07:07:08.551]         }
  [07:07:08.551]         else {
  [07:07:08.551]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.551]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.551]         }
  [07:07:08.551]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.551]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.551]             base::sink(type = "output", split = FALSE)
  [07:07:08.551]             base::close(...future.stdout)
  [07:07:08.551]         }, add = TRUE)
  [07:07:08.551]     }
  [07:07:08.551]     ...future.frame <- base::sys.nframe()
  [07:07:08.551]     ...future.conditions <- base::list()
  [07:07:08.551]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.551]     ...future.result <- base::tryCatch({
  [07:07:08.551]         base::withCallingHandlers({
  [07:07:08.551]             ...future.value <- base::withVisible(base::local({
  [07:07:08.551]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.551]             }))
  [07:07:08.551]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.551]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.551]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.551]                 version = "1.8")
  [07:07:08.551]         }, condition = base::local({
  [07:07:08.551]             c <- base::c
  [07:07:08.551]             inherits <- base::inherits
  [07:07:08.551]             invokeRestart <- base::invokeRestart
  [07:07:08.551]             length <- base::length
  [07:07:08.551]             list <- base::list
  [07:07:08.551]             seq.int <- base::seq.int
  [07:07:08.551]             signalCondition <- base::signalCondition
  [07:07:08.551]             sys.calls <- base::sys.calls
  [07:07:08.551]             Sys.time <- base::Sys.time
  [07:07:08.551]             `[[` <- base::`[[`
  [07:07:08.551]             `+` <- base::`+`
  [07:07:08.551]             `<<-` <- base::`<<-`
  [07:07:08.551]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.551]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.551]                   3L)]
  [07:07:08.551]             }
  [07:07:08.551]             function(cond) {
  [07:07:08.551]                 if (inherits(cond, "error")) {
  [07:07:08.551]                   sessionInformation <- function() {
  [07:07:08.551]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.551]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.551]                       search = base::search(), system = base::Sys.info())
  [07:07:08.551]                   }
  [07:07:08.551]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.551]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.551]                     cond$call), session = sessionInformation(), 
  [07:07:08.551]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.551]                   signalCondition(cond)
  [07:07:08.551]                 }
  [07:07:08.551]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.551]                 ))) {
  [07:07:08.551]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.551]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.551]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.551]                   if (!signal) {
  [07:07:08.551]                     muffleCondition <- function (cond) 
  [07:07:08.551]                     {
  [07:07:08.551]                       inherits <- base::inherits
  [07:07:08.551]                       invokeRestart <- base::invokeRestart
  [07:07:08.551]                       muffled <- FALSE
  [07:07:08.551]                       if (inherits(cond, "message")) {
  [07:07:08.551]                         invokeRestart("muffleMessage")
  [07:07:08.551]                         muffled <- TRUE
  [07:07:08.551]                       }
  [07:07:08.551]                       else if (inherits(cond, "warning")) {
  [07:07:08.551]                         invokeRestart("muffleWarning")
  [07:07:08.551]                         muffled <- TRUE
  [07:07:08.551]                       }
  [07:07:08.551]                       else if (inherits(cond, "condition")) {
  [07:07:08.551]                         computeRestarts <- base::computeRestarts
  [07:07:08.551]                         grepl <- base::grepl
  [07:07:08.551]                         is.null <- base::is.null
  [07:07:08.551]                         restarts <- computeRestarts(cond)
  [07:07:08.551]                         for (restart in restarts) {
  [07:07:08.551]                           name <- restart$name
  [07:07:08.551]                           if (is.null(name)) 
  [07:07:08.551]                             next
  [07:07:08.551]                           if (!grepl("^muffle", name)) 
  [07:07:08.551]                             next
  [07:07:08.551]                           invokeRestart(restart)
  [07:07:08.551]                           muffled <- TRUE
  [07:07:08.551]                           break
  [07:07:08.551]                         }
  [07:07:08.551]                       }
  [07:07:08.551]                       invisible(muffled)
  [07:07:08.551]                     }
  [07:07:08.551]                     muffleCondition(cond)
  [07:07:08.551]                   }
  [07:07:08.551]                 }
  [07:07:08.551]             }
  [07:07:08.551]         }))
  [07:07:08.551]     }, error = function(ex) {
  [07:07:08.551]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.551]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.551]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.551]     }, finally = {
  [07:07:08.551]         {
  [07:07:08.551]             NULL
  [07:07:08.551]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.551]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.551]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.551]                 label = NULL, ...) 
  [07:07:08.551]             {
  [07:07:08.551]                 if (substitute) 
  [07:07:08.551]                   expr <- substitute(expr)
  [07:07:08.551]                 local <- as.logical(local)
  [07:07:08.551]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.551]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.551]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.551]                   label = label, ...)
  [07:07:08.551]                 if (!future$lazy) 
  [07:07:08.551]                   future <- run(future)
  [07:07:08.551]                 invisible(future)
  [07:07:08.551]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.551]         }
  [07:07:08.551]         base::options(...future.oldOptions)
  [07:07:08.551]     })
  [07:07:08.551]     Sys.time
  [07:07:08.551]     if (base::is.na(NA)) {
  [07:07:08.551]     }
  [07:07:08.551]     else {
  [07:07:08.551]         base::sink(type = "output", split = FALSE)
  [07:07:08.551]         if (NA) {
  [07:07:08.551]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.551]         }
  [07:07:08.551]         else {
  [07:07:08.551]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.551]         }
  [07:07:08.551]         base::close(...future.stdout)
  [07:07:08.551]         ...future.stdout <- NULL
  [07:07:08.551]     }
  [07:07:08.551]     ...future.result$conditions <- ...future.conditions
  [07:07:08.551]     ...future.result
  [07:07:08.551] }
  [07:07:08.560] plan(): Setting new future strategy stack:
  [07:07:08.562] List of future strategies:
  [07:07:08.562] 1. sequential:
  [07:07:08.562]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.562]    - tweaked: FALSE
  [07:07:08.562]    - call: NULL
  [07:07:08.566] plan(): nbrOfWorkers() = 1
  [07:07:08.571] Packages needed by the future expression (n = 0): <none>
  [07:07:08.573] Packages needed by future strategies (n = 0): <none>
  [07:07:08.583] {
  [07:07:08.583]     {
  [07:07:08.583]         ...future.startTime <- base::Sys.time()
  [07:07:08.583]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.583]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.583]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.583]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.583]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.583]         {
  [07:07:08.583]             {
  [07:07:08.583]                 base::local({
  [07:07:08.583]                   has_future <- base::requireNamespace("future", 
  [07:07:08.583]                     quietly = TRUE)
  [07:07:08.583]                   version <- if (has_future) 
  [07:07:08.583]                     utils::packageVersion("future")
  [07:07:08.583]                   else NULL
  [07:07:08.583]                   if (!has_future || version < "1.8.0") {
  [07:07:08.583]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.583]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.583]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.583]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.583]                         "release", "version")], collapse = " "), 
  [07:07:08.583]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.583]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.583]                       info)
  [07:07:08.583]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.583]                     if (!has_future) {
  [07:07:08.583]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.583]                         info)
  [07:07:08.583]                     }
  [07:07:08.583]                     else {
  [07:07:08.583]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.583]                         info, version)
  [07:07:08.583]                     }
  [07:07:08.583]                     base::stop(msg)
  [07:07:08.583]                   }
  [07:07:08.583]                 })
  [07:07:08.583]             }
  [07:07:08.583]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.583]         }
  [07:07:08.583]     }
  [07:07:08.583]     if (base::is.na(NA)) {
  [07:07:08.583]     }
  [07:07:08.583]     else {
  [07:07:08.583]         if (NA) {
  [07:07:08.583]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.583]                 open = "w")
  [07:07:08.583]         }
  [07:07:08.583]         else {
  [07:07:08.583]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.583]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.583]         }
  [07:07:08.583]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.583]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.583]             base::sink(type = "output", split = FALSE)
  [07:07:08.583]             base::close(...future.stdout)
  [07:07:08.583]         }, add = TRUE)
  [07:07:08.583]     }
  [07:07:08.583]     ...future.frame <- base::sys.nframe()
  [07:07:08.583]     ...future.conditions <- base::list()
  [07:07:08.583]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.583]     ...future.result <- base::tryCatch({
  [07:07:08.583]         base::withCallingHandlers({
  [07:07:08.583]             ...future.value <- base::withVisible(base::local({
  [07:07:08.583]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.583]             }))
  [07:07:08.583]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.583]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.583]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.583]                 version = "1.8")
  [07:07:08.583]         }, condition = base::local({
  [07:07:08.583]             c <- base::c
  [07:07:08.583]             inherits <- base::inherits
  [07:07:08.583]             invokeRestart <- base::invokeRestart
  [07:07:08.583]             length <- base::length
  [07:07:08.583]             list <- base::list
  [07:07:08.583]             seq.int <- base::seq.int
  [07:07:08.583]             signalCondition <- base::signalCondition
  [07:07:08.583]             sys.calls <- base::sys.calls
  [07:07:08.583]             Sys.time <- base::Sys.time
  [07:07:08.583]             `[[` <- base::`[[`
  [07:07:08.583]             `+` <- base::`+`
  [07:07:08.583]             `<<-` <- base::`<<-`
  [07:07:08.583]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.583]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.583]                   3L)]
  [07:07:08.583]             }
  [07:07:08.583]             function(cond) {
  [07:07:08.583]                 if (inherits(cond, "error")) {
  [07:07:08.583]                   sessionInformation <- function() {
  [07:07:08.583]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.583]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.583]                       search = base::search(), system = base::Sys.info())
  [07:07:08.583]                   }
  [07:07:08.583]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.583]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.583]                     cond$call), session = sessionInformation(), 
  [07:07:08.583]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.583]                   signalCondition(cond)
  [07:07:08.583]                 }
  [07:07:08.583]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.583]                 ))) {
  [07:07:08.583]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.583]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.583]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.583]                   if (!signal) {
  [07:07:08.583]                     muffleCondition <- function (cond) 
  [07:07:08.583]                     {
  [07:07:08.583]                       inherits <- base::inherits
  [07:07:08.583]                       invokeRestart <- base::invokeRestart
  [07:07:08.583]                       muffled <- FALSE
  [07:07:08.583]                       if (inherits(cond, "message")) {
  [07:07:08.583]                         invokeRestart("muffleMessage")
  [07:07:08.583]                         muffled <- TRUE
  [07:07:08.583]                       }
  [07:07:08.583]                       else if (inherits(cond, "warning")) {
  [07:07:08.583]                         invokeRestart("muffleWarning")
  [07:07:08.583]                         muffled <- TRUE
  [07:07:08.583]                       }
  [07:07:08.583]                       else if (inherits(cond, "condition")) {
  [07:07:08.583]                         computeRestarts <- base::computeRestarts
  [07:07:08.583]                         grepl <- base::grepl
  [07:07:08.583]                         is.null <- base::is.null
  [07:07:08.583]                         restarts <- computeRestarts(cond)
  [07:07:08.583]                         for (restart in restarts) {
  [07:07:08.583]                           name <- restart$name
  [07:07:08.583]                           if (is.null(name)) 
  [07:07:08.583]                             next
  [07:07:08.583]                           if (!grepl("^muffle", name)) 
  [07:07:08.583]                             next
  [07:07:08.583]                           invokeRestart(restart)
  [07:07:08.583]                           muffled <- TRUE
  [07:07:08.583]                           break
  [07:07:08.583]                         }
  [07:07:08.583]                       }
  [07:07:08.583]                       invisible(muffled)
  [07:07:08.583]                     }
  [07:07:08.583]                     muffleCondition(cond)
  [07:07:08.583]                   }
  [07:07:08.583]                 }
  [07:07:08.583]             }
  [07:07:08.583]         }))
  [07:07:08.583]     }, error = function(ex) {
  [07:07:08.583]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.583]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.583]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.583]     }, finally = {
  [07:07:08.583]         {
  [07:07:08.583]             NULL
  [07:07:08.583]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.583]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.583]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.583]                 label = NULL, ...) 
  [07:07:08.583]             {
  [07:07:08.583]                 if (substitute) 
  [07:07:08.583]                   expr <- substitute(expr)
  [07:07:08.583]                 local <- as.logical(local)
  [07:07:08.583]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.583]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.583]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.583]                   label = label, ...)
  [07:07:08.583]                 if (!future$lazy) 
  [07:07:08.583]                   future <- run(future)
  [07:07:08.583]                 invisible(future)
  [07:07:08.583]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.583]         }
  [07:07:08.583]         base::options(...future.oldOptions)
  [07:07:08.583]     })
  [07:07:08.583]     Sys.time
  [07:07:08.583]     if (base::is.na(NA)) {
  [07:07:08.583]     }
  [07:07:08.583]     else {
  [07:07:08.583]         base::sink(type = "output", split = FALSE)
  [07:07:08.583]         if (NA) {
  [07:07:08.583]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.583]         }
  [07:07:08.583]         else {
  [07:07:08.583]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.583]         }
  [07:07:08.583]         base::close(...future.stdout)
  [07:07:08.583]         ...future.stdout <- NULL
  [07:07:08.583]     }
  [07:07:08.583]     ...future.result$conditions <- ...future.conditions
  [07:07:08.583]     ...future.result
  [07:07:08.583] }
  [07:07:08.593] plan(): Setting new future strategy stack:
  [07:07:08.595] List of future strategies:
  [07:07:08.595] 1. sequential:
  [07:07:08.595]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.595]    - tweaked: FALSE
  [07:07:08.595]    - call: NULL
  [07:07:08.599] plan(): nbrOfWorkers() = 1
  [07:07:08.604] Packages needed by the future expression (n = 0): <none>
  [07:07:08.607] Packages needed by future strategies (n = 0): <none>
  [07:07:08.617] {
  [07:07:08.617]     {
  [07:07:08.617]         ...future.startTime <- base::Sys.time()
  [07:07:08.617]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.617]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.617]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.617]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.617]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.617]         {
  [07:07:08.617]             {
  [07:07:08.617]                 base::local({
  [07:07:08.617]                   has_future <- base::requireNamespace("future", 
  [07:07:08.617]                     quietly = TRUE)
  [07:07:08.617]                   version <- if (has_future) 
  [07:07:08.617]                     utils::packageVersion("future")
  [07:07:08.617]                   else NULL
  [07:07:08.617]                   if (!has_future || version < "1.8.0") {
  [07:07:08.617]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.617]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.617]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.617]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.617]                         "release", "version")], collapse = " "), 
  [07:07:08.617]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.617]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.617]                       info)
  [07:07:08.617]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.617]                     if (!has_future) {
  [07:07:08.617]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.617]                         info)
  [07:07:08.617]                     }
  [07:07:08.617]                     else {
  [07:07:08.617]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.617]                         info, version)
  [07:07:08.617]                     }
  [07:07:08.617]                     base::stop(msg)
  [07:07:08.617]                   }
  [07:07:08.617]                 })
  [07:07:08.617]             }
  [07:07:08.617]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.617]         }
  [07:07:08.617]     }
  [07:07:08.617]     if (base::is.na(NA)) {
  [07:07:08.617]     }
  [07:07:08.617]     else {
  [07:07:08.617]         if (NA) {
  [07:07:08.617]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.617]                 open = "w")
  [07:07:08.617]         }
  [07:07:08.617]         else {
  [07:07:08.617]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.617]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.617]         }
  [07:07:08.617]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.617]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.617]             base::sink(type = "output", split = FALSE)
  [07:07:08.617]             base::close(...future.stdout)
  [07:07:08.617]         }, add = TRUE)
  [07:07:08.617]     }
  [07:07:08.617]     ...future.frame <- base::sys.nframe()
  [07:07:08.617]     ...future.conditions <- base::list()
  [07:07:08.617]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.617]     ...future.result <- base::tryCatch({
  [07:07:08.617]         base::withCallingHandlers({
  [07:07:08.617]             ...future.value <- base::withVisible(base::local({
  [07:07:08.617]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.617]             }))
  [07:07:08.617]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.617]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.617]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.617]                 version = "1.8")
  [07:07:08.617]         }, condition = base::local({
  [07:07:08.617]             c <- base::c
  [07:07:08.617]             inherits <- base::inherits
  [07:07:08.617]             invokeRestart <- base::invokeRestart
  [07:07:08.617]             length <- base::length
  [07:07:08.617]             list <- base::list
  [07:07:08.617]             seq.int <- base::seq.int
  [07:07:08.617]             signalCondition <- base::signalCondition
  [07:07:08.617]             sys.calls <- base::sys.calls
  [07:07:08.617]             Sys.time <- base::Sys.time
  [07:07:08.617]             `[[` <- base::`[[`
  [07:07:08.617]             `+` <- base::`+`
  [07:07:08.617]             `<<-` <- base::`<<-`
  [07:07:08.617]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.617]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.617]                   3L)]
  [07:07:08.617]             }
  [07:07:08.617]             function(cond) {
  [07:07:08.617]                 if (inherits(cond, "error")) {
  [07:07:08.617]                   sessionInformation <- function() {
  [07:07:08.617]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.617]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.617]                       search = base::search(), system = base::Sys.info())
  [07:07:08.617]                   }
  [07:07:08.617]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.617]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.617]                     cond$call), session = sessionInformation(), 
  [07:07:08.617]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.617]                   signalCondition(cond)
  [07:07:08.617]                 }
  [07:07:08.617]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.617]                 ))) {
  [07:07:08.617]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.617]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.617]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.617]                   if (!signal) {
  [07:07:08.617]                     muffleCondition <- function (cond) 
  [07:07:08.617]                     {
  [07:07:08.617]                       inherits <- base::inherits
  [07:07:08.617]                       invokeRestart <- base::invokeRestart
  [07:07:08.617]                       muffled <- FALSE
  [07:07:08.617]                       if (inherits(cond, "message")) {
  [07:07:08.617]                         invokeRestart("muffleMessage")
  [07:07:08.617]                         muffled <- TRUE
  [07:07:08.617]                       }
  [07:07:08.617]                       else if (inherits(cond, "warning")) {
  [07:07:08.617]                         invokeRestart("muffleWarning")
  [07:07:08.617]                         muffled <- TRUE
  [07:07:08.617]                       }
  [07:07:08.617]                       else if (inherits(cond, "condition")) {
  [07:07:08.617]                         computeRestarts <- base::computeRestarts
  [07:07:08.617]                         grepl <- base::grepl
  [07:07:08.617]                         is.null <- base::is.null
  [07:07:08.617]                         restarts <- computeRestarts(cond)
  [07:07:08.617]                         for (restart in restarts) {
  [07:07:08.617]                           name <- restart$name
  [07:07:08.617]                           if (is.null(name)) 
  [07:07:08.617]                             next
  [07:07:08.617]                           if (!grepl("^muffle", name)) 
  [07:07:08.617]                             next
  [07:07:08.617]                           invokeRestart(restart)
  [07:07:08.617]                           muffled <- TRUE
  [07:07:08.617]                           break
  [07:07:08.617]                         }
  [07:07:08.617]                       }
  [07:07:08.617]                       invisible(muffled)
  [07:07:08.617]                     }
  [07:07:08.617]                     muffleCondition(cond)
  [07:07:08.617]                   }
  [07:07:08.617]                 }
  [07:07:08.617]             }
  [07:07:08.617]         }))
  [07:07:08.617]     }, error = function(ex) {
  [07:07:08.617]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.617]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.617]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.617]     }, finally = {
  [07:07:08.617]         {
  [07:07:08.617]             NULL
  [07:07:08.617]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.617]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.617]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.617]                 label = NULL, ...) 
  [07:07:08.617]             {
  [07:07:08.617]                 if (substitute) 
  [07:07:08.617]                   expr <- substitute(expr)
  [07:07:08.617]                 local <- as.logical(local)
  [07:07:08.617]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.617]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.617]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.617]                   label = label, ...)
  [07:07:08.617]                 if (!future$lazy) 
  [07:07:08.617]                   future <- run(future)
  [07:07:08.617]                 invisible(future)
  [07:07:08.617]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.617]         }
  [07:07:08.617]         base::options(...future.oldOptions)
  [07:07:08.617]     })
  [07:07:08.617]     Sys.time
  [07:07:08.617]     if (base::is.na(NA)) {
  [07:07:08.617]     }
  [07:07:08.617]     else {
  [07:07:08.617]         base::sink(type = "output", split = FALSE)
  [07:07:08.617]         if (NA) {
  [07:07:08.617]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.617]         }
  [07:07:08.617]         else {
  [07:07:08.617]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.617]         }
  [07:07:08.617]         base::close(...future.stdout)
  [07:07:08.617]         ...future.stdout <- NULL
  [07:07:08.617]     }
  [07:07:08.617]     ...future.result$conditions <- ...future.conditions
  [07:07:08.617]     ...future.result
  [07:07:08.617] }
  [07:07:08.627] plan(): Setting new future strategy stack:
  [07:07:08.629] List of future strategies:
  [07:07:08.629] 1. sequential:
  [07:07:08.629]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.629]    - tweaked: FALSE
  [07:07:08.629]    - call: NULL
  [07:07:08.633] plan(): nbrOfWorkers() = 1
  [07:07:08.643] Packages needed by the future expression (n = 0): <none>
  [07:07:08.646] Packages needed by future strategies (n = 0): <none>
  [07:07:08.657] {
  [07:07:08.657]     {
  [07:07:08.657]         ...future.startTime <- base::Sys.time()
  [07:07:08.657]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.657]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.657]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.657]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.657]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.657]         {
  [07:07:08.657]             {
  [07:07:08.657]                 base::local({
  [07:07:08.657]                   has_future <- base::requireNamespace("future", 
  [07:07:08.657]                     quietly = TRUE)
  [07:07:08.657]                   version <- if (has_future) 
  [07:07:08.657]                     utils::packageVersion("future")
  [07:07:08.657]                   else NULL
  [07:07:08.657]                   if (!has_future || version < "1.8.0") {
  [07:07:08.657]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.657]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.657]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.657]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.657]                         "release", "version")], collapse = " "), 
  [07:07:08.657]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.657]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.657]                       info)
  [07:07:08.657]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.657]                     if (!has_future) {
  [07:07:08.657]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.657]                         info)
  [07:07:08.657]                     }
  [07:07:08.657]                     else {
  [07:07:08.657]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.657]                         info, version)
  [07:07:08.657]                     }
  [07:07:08.657]                     base::stop(msg)
  [07:07:08.657]                   }
  [07:07:08.657]                 })
  [07:07:08.657]             }
  [07:07:08.657]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.657]         }
  [07:07:08.657]     }
  [07:07:08.657]     if (base::is.na(NA)) {
  [07:07:08.657]     }
  [07:07:08.657]     else {
  [07:07:08.657]         if (NA) {
  [07:07:08.657]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.657]                 open = "w")
  [07:07:08.657]         }
  [07:07:08.657]         else {
  [07:07:08.657]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.657]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.657]         }
  [07:07:08.657]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.657]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.657]             base::sink(type = "output", split = FALSE)
  [07:07:08.657]             base::close(...future.stdout)
  [07:07:08.657]         }, add = TRUE)
  [07:07:08.657]     }
  [07:07:08.657]     ...future.frame <- base::sys.nframe()
  [07:07:08.657]     ...future.conditions <- base::list()
  [07:07:08.657]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.657]     ...future.result <- base::tryCatch({
  [07:07:08.657]         base::withCallingHandlers({
  [07:07:08.657]             ...future.value <- base::withVisible(base::local({
  [07:07:08.657]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.657]             }))
  [07:07:08.657]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.657]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.657]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.657]                 version = "1.8")
  [07:07:08.657]         }, condition = base::local({
  [07:07:08.657]             c <- base::c
  [07:07:08.657]             inherits <- base::inherits
  [07:07:08.657]             invokeRestart <- base::invokeRestart
  [07:07:08.657]             length <- base::length
  [07:07:08.657]             list <- base::list
  [07:07:08.657]             seq.int <- base::seq.int
  [07:07:08.657]             signalCondition <- base::signalCondition
  [07:07:08.657]             sys.calls <- base::sys.calls
  [07:07:08.657]             Sys.time <- base::Sys.time
  [07:07:08.657]             `[[` <- base::`[[`
  [07:07:08.657]             `+` <- base::`+`
  [07:07:08.657]             `<<-` <- base::`<<-`
  [07:07:08.657]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.657]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.657]                   3L)]
  [07:07:08.657]             }
  [07:07:08.657]             function(cond) {
  [07:07:08.657]                 if (inherits(cond, "error")) {
  [07:07:08.657]                   sessionInformation <- function() {
  [07:07:08.657]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.657]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.657]                       search = base::search(), system = base::Sys.info())
  [07:07:08.657]                   }
  [07:07:08.657]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.657]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.657]                     cond$call), session = sessionInformation(), 
  [07:07:08.657]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.657]                   signalCondition(cond)
  [07:07:08.657]                 }
  [07:07:08.657]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.657]                 ))) {
  [07:07:08.657]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.657]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.657]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.657]                   if (!signal) {
  [07:07:08.657]                     muffleCondition <- function (cond) 
  [07:07:08.657]                     {
  [07:07:08.657]                       inherits <- base::inherits
  [07:07:08.657]                       invokeRestart <- base::invokeRestart
  [07:07:08.657]                       muffled <- FALSE
  [07:07:08.657]                       if (inherits(cond, "message")) {
  [07:07:08.657]                         invokeRestart("muffleMessage")
  [07:07:08.657]                         muffled <- TRUE
  [07:07:08.657]                       }
  [07:07:08.657]                       else if (inherits(cond, "warning")) {
  [07:07:08.657]                         invokeRestart("muffleWarning")
  [07:07:08.657]                         muffled <- TRUE
  [07:07:08.657]                       }
  [07:07:08.657]                       else if (inherits(cond, "condition")) {
  [07:07:08.657]                         computeRestarts <- base::computeRestarts
  [07:07:08.657]                         grepl <- base::grepl
  [07:07:08.657]                         is.null <- base::is.null
  [07:07:08.657]                         restarts <- computeRestarts(cond)
  [07:07:08.657]                         for (restart in restarts) {
  [07:07:08.657]                           name <- restart$name
  [07:07:08.657]                           if (is.null(name)) 
  [07:07:08.657]                             next
  [07:07:08.657]                           if (!grepl("^muffle", name)) 
  [07:07:08.657]                             next
  [07:07:08.657]                           invokeRestart(restart)
  [07:07:08.657]                           muffled <- TRUE
  [07:07:08.657]                           break
  [07:07:08.657]                         }
  [07:07:08.657]                       }
  [07:07:08.657]                       invisible(muffled)
  [07:07:08.657]                     }
  [07:07:08.657]                     muffleCondition(cond)
  [07:07:08.657]                   }
  [07:07:08.657]                 }
  [07:07:08.657]             }
  [07:07:08.657]         }))
  [07:07:08.657]     }, error = function(ex) {
  [07:07:08.657]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.657]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.657]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.657]     }, finally = {
  [07:07:08.657]         {
  [07:07:08.657]             NULL
  [07:07:08.657]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.657]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.657]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.657]                 label = NULL, ...) 
  [07:07:08.657]             {
  [07:07:08.657]                 if (substitute) 
  [07:07:08.657]                   expr <- substitute(expr)
  [07:07:08.657]                 local <- as.logical(local)
  [07:07:08.657]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.657]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.657]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.657]                   label = label, ...)
  [07:07:08.657]                 if (!future$lazy) 
  [07:07:08.657]                   future <- run(future)
  [07:07:08.657]                 invisible(future)
  [07:07:08.657]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.657]         }
  [07:07:08.657]         base::options(...future.oldOptions)
  [07:07:08.657]     })
  [07:07:08.657]     Sys.time
  [07:07:08.657]     if (base::is.na(NA)) {
  [07:07:08.657]     }
  [07:07:08.657]     else {
  [07:07:08.657]         base::sink(type = "output", split = FALSE)
  [07:07:08.657]         if (NA) {
  [07:07:08.657]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.657]         }
  [07:07:08.657]         else {
  [07:07:08.657]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.657]         }
  [07:07:08.657]         base::close(...future.stdout)
  [07:07:08.657]         ...future.stdout <- NULL
  [07:07:08.657]     }
  [07:07:08.657]     ...future.result$conditions <- ...future.conditions
  [07:07:08.657]     ...future.result
  [07:07:08.657] }
  [07:07:08.667] plan(): Setting new future strategy stack:
  [07:07:08.670] List of future strategies:
  [07:07:08.670] 1. sequential:
  [07:07:08.670]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.670]    - tweaked: FALSE
  [07:07:08.670]    - call: NULL
  [07:07:08.674] plan(): nbrOfWorkers() = 1
  [07:07:08.679] Packages needed by the future expression (n = 0): <none>
  [07:07:08.682] Packages needed by future strategies (n = 0): <none>
  [07:07:08.693] {
  [07:07:08.693]     {
  [07:07:08.693]         ...future.startTime <- base::Sys.time()
  [07:07:08.693]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.693]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.693]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.693]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.693]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.693]         {
  [07:07:08.693]             {
  [07:07:08.693]                 base::local({
  [07:07:08.693]                   has_future <- base::requireNamespace("future", 
  [07:07:08.693]                     quietly = TRUE)
  [07:07:08.693]                   version <- if (has_future) 
  [07:07:08.693]                     utils::packageVersion("future")
  [07:07:08.693]                   else NULL
  [07:07:08.693]                   if (!has_future || version < "1.8.0") {
  [07:07:08.693]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.693]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.693]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.693]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.693]                         "release", "version")], collapse = " "), 
  [07:07:08.693]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.693]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.693]                       info)
  [07:07:08.693]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.693]                     if (!has_future) {
  [07:07:08.693]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.693]                         info)
  [07:07:08.693]                     }
  [07:07:08.693]                     else {
  [07:07:08.693]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.693]                         info, version)
  [07:07:08.693]                     }
  [07:07:08.693]                     base::stop(msg)
  [07:07:08.693]                   }
  [07:07:08.693]                 })
  [07:07:08.693]             }
  [07:07:08.693]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.693]         }
  [07:07:08.693]     }
  [07:07:08.693]     if (base::is.na(NA)) {
  [07:07:08.693]     }
  [07:07:08.693]     else {
  [07:07:08.693]         if (NA) {
  [07:07:08.693]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.693]                 open = "w")
  [07:07:08.693]         }
  [07:07:08.693]         else {
  [07:07:08.693]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.693]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.693]         }
  [07:07:08.693]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.693]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.693]             base::sink(type = "output", split = FALSE)
  [07:07:08.693]             base::close(...future.stdout)
  [07:07:08.693]         }, add = TRUE)
  [07:07:08.693]     }
  [07:07:08.693]     ...future.frame <- base::sys.nframe()
  [07:07:08.693]     ...future.conditions <- base::list()
  [07:07:08.693]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.693]     ...future.result <- base::tryCatch({
  [07:07:08.693]         base::withCallingHandlers({
  [07:07:08.693]             ...future.value <- base::withVisible(base::local({
  [07:07:08.693]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.693]             }))
  [07:07:08.693]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.693]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.693]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.693]                 version = "1.8")
  [07:07:08.693]         }, condition = base::local({
  [07:07:08.693]             c <- base::c
  [07:07:08.693]             inherits <- base::inherits
  [07:07:08.693]             invokeRestart <- base::invokeRestart
  [07:07:08.693]             length <- base::length
  [07:07:08.693]             list <- base::list
  [07:07:08.693]             seq.int <- base::seq.int
  [07:07:08.693]             signalCondition <- base::signalCondition
  [07:07:08.693]             sys.calls <- base::sys.calls
  [07:07:08.693]             Sys.time <- base::Sys.time
  [07:07:08.693]             `[[` <- base::`[[`
  [07:07:08.693]             `+` <- base::`+`
  [07:07:08.693]             `<<-` <- base::`<<-`
  [07:07:08.693]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.693]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.693]                   3L)]
  [07:07:08.693]             }
  [07:07:08.693]             function(cond) {
  [07:07:08.693]                 if (inherits(cond, "error")) {
  [07:07:08.693]                   sessionInformation <- function() {
  [07:07:08.693]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.693]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.693]                       search = base::search(), system = base::Sys.info())
  [07:07:08.693]                   }
  [07:07:08.693]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.693]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.693]                     cond$call), session = sessionInformation(), 
  [07:07:08.693]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.693]                   signalCondition(cond)
  [07:07:08.693]                 }
  [07:07:08.693]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.693]                 ))) {
  [07:07:08.693]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.693]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.693]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.693]                   if (!signal) {
  [07:07:08.693]                     muffleCondition <- function (cond) 
  [07:07:08.693]                     {
  [07:07:08.693]                       inherits <- base::inherits
  [07:07:08.693]                       invokeRestart <- base::invokeRestart
  [07:07:08.693]                       muffled <- FALSE
  [07:07:08.693]                       if (inherits(cond, "message")) {
  [07:07:08.693]                         invokeRestart("muffleMessage")
  [07:07:08.693]                         muffled <- TRUE
  [07:07:08.693]                       }
  [07:07:08.693]                       else if (inherits(cond, "warning")) {
  [07:07:08.693]                         invokeRestart("muffleWarning")
  [07:07:08.693]                         muffled <- TRUE
  [07:07:08.693]                       }
  [07:07:08.693]                       else if (inherits(cond, "condition")) {
  [07:07:08.693]                         computeRestarts <- base::computeRestarts
  [07:07:08.693]                         grepl <- base::grepl
  [07:07:08.693]                         is.null <- base::is.null
  [07:07:08.693]                         restarts <- computeRestarts(cond)
  [07:07:08.693]                         for (restart in restarts) {
  [07:07:08.693]                           name <- restart$name
  [07:07:08.693]                           if (is.null(name)) 
  [07:07:08.693]                             next
  [07:07:08.693]                           if (!grepl("^muffle", name)) 
  [07:07:08.693]                             next
  [07:07:08.693]                           invokeRestart(restart)
  [07:07:08.693]                           muffled <- TRUE
  [07:07:08.693]                           break
  [07:07:08.693]                         }
  [07:07:08.693]                       }
  [07:07:08.693]                       invisible(muffled)
  [07:07:08.693]                     }
  [07:07:08.693]                     muffleCondition(cond)
  [07:07:08.693]                   }
  [07:07:08.693]                 }
  [07:07:08.693]             }
  [07:07:08.693]         }))
  [07:07:08.693]     }, error = function(ex) {
  [07:07:08.693]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.693]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.693]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.693]     }, finally = {
  [07:07:08.693]         {
  [07:07:08.693]             NULL
  [07:07:08.693]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.693]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.693]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.693]                 label = NULL, ...) 
  [07:07:08.693]             {
  [07:07:08.693]                 if (substitute) 
  [07:07:08.693]                   expr <- substitute(expr)
  [07:07:08.693]                 local <- as.logical(local)
  [07:07:08.693]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.693]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.693]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.693]                   label = label, ...)
  [07:07:08.693]                 if (!future$lazy) 
  [07:07:08.693]                   future <- run(future)
  [07:07:08.693]                 invisible(future)
  [07:07:08.693]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.693]         }
  [07:07:08.693]         base::options(...future.oldOptions)
  [07:07:08.693]     })
  [07:07:08.693]     Sys.time
  [07:07:08.693]     if (base::is.na(NA)) {
  [07:07:08.693]     }
  [07:07:08.693]     else {
  [07:07:08.693]         base::sink(type = "output", split = FALSE)
  [07:07:08.693]         if (NA) {
  [07:07:08.693]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.693]         }
  [07:07:08.693]         else {
  [07:07:08.693]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.693]         }
  [07:07:08.693]         base::close(...future.stdout)
  [07:07:08.693]         ...future.stdout <- NULL
  [07:07:08.693]     }
  [07:07:08.693]     ...future.result$conditions <- ...future.conditions
  [07:07:08.693]     ...future.result
  [07:07:08.693] }
  [07:07:08.703] plan(): Setting new future strategy stack:
  [07:07:08.706] List of future strategies:
  [07:07:08.706] 1. sequential:
  [07:07:08.706]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.706]    - tweaked: FALSE
  [07:07:08.706]    - call: NULL
  [07:07:08.710] plan(): nbrOfWorkers() = 1
  [07:07:08.715] Packages needed by the future expression (n = 0): <none>
  [07:07:08.718] Packages needed by future strategies (n = 0): <none>
  [07:07:08.727] {
  [07:07:08.727]     {
  [07:07:08.727]         ...future.startTime <- base::Sys.time()
  [07:07:08.727]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.727]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.727]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.727]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.727]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.727]         {
  [07:07:08.727]             {
  [07:07:08.727]                 base::local({
  [07:07:08.727]                   has_future <- base::requireNamespace("future", 
  [07:07:08.727]                     quietly = TRUE)
  [07:07:08.727]                   version <- if (has_future) 
  [07:07:08.727]                     utils::packageVersion("future")
  [07:07:08.727]                   else NULL
  [07:07:08.727]                   if (!has_future || version < "1.8.0") {
  [07:07:08.727]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.727]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.727]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.727]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.727]                         "release", "version")], collapse = " "), 
  [07:07:08.727]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.727]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.727]                       info)
  [07:07:08.727]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.727]                     if (!has_future) {
  [07:07:08.727]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.727]                         info)
  [07:07:08.727]                     }
  [07:07:08.727]                     else {
  [07:07:08.727]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.727]                         info, version)
  [07:07:08.727]                     }
  [07:07:08.727]                     base::stop(msg)
  [07:07:08.727]                   }
  [07:07:08.727]                 })
  [07:07:08.727]             }
  [07:07:08.727]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.727]         }
  [07:07:08.727]     }
  [07:07:08.727]     if (base::is.na(NA)) {
  [07:07:08.727]     }
  [07:07:08.727]     else {
  [07:07:08.727]         if (NA) {
  [07:07:08.727]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.727]                 open = "w")
  [07:07:08.727]         }
  [07:07:08.727]         else {
  [07:07:08.727]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.727]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.727]         }
  [07:07:08.727]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.727]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.727]             base::sink(type = "output", split = FALSE)
  [07:07:08.727]             base::close(...future.stdout)
  [07:07:08.727]         }, add = TRUE)
  [07:07:08.727]     }
  [07:07:08.727]     ...future.frame <- base::sys.nframe()
  [07:07:08.727]     ...future.conditions <- base::list()
  [07:07:08.727]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.727]     ...future.result <- base::tryCatch({
  [07:07:08.727]         base::withCallingHandlers({
  [07:07:08.727]             ...future.value <- base::withVisible(base::local({
  [07:07:08.727]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.727]             }))
  [07:07:08.727]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.727]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.727]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.727]                 version = "1.8")
  [07:07:08.727]         }, condition = base::local({
  [07:07:08.727]             c <- base::c
  [07:07:08.727]             inherits <- base::inherits
  [07:07:08.727]             invokeRestart <- base::invokeRestart
  [07:07:08.727]             length <- base::length
  [07:07:08.727]             list <- base::list
  [07:07:08.727]             seq.int <- base::seq.int
  [07:07:08.727]             signalCondition <- base::signalCondition
  [07:07:08.727]             sys.calls <- base::sys.calls
  [07:07:08.727]             Sys.time <- base::Sys.time
  [07:07:08.727]             `[[` <- base::`[[`
  [07:07:08.727]             `+` <- base::`+`
  [07:07:08.727]             `<<-` <- base::`<<-`
  [07:07:08.727]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.727]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.727]                   3L)]
  [07:07:08.727]             }
  [07:07:08.727]             function(cond) {
  [07:07:08.727]                 if (inherits(cond, "error")) {
  [07:07:08.727]                   sessionInformation <- function() {
  [07:07:08.727]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.727]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.727]                       search = base::search(), system = base::Sys.info())
  [07:07:08.727]                   }
  [07:07:08.727]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.727]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.727]                     cond$call), session = sessionInformation(), 
  [07:07:08.727]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.727]                   signalCondition(cond)
  [07:07:08.727]                 }
  [07:07:08.727]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.727]                 ))) {
  [07:07:08.727]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.727]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.727]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.727]                   if (!signal) {
  [07:07:08.727]                     muffleCondition <- function (cond) 
  [07:07:08.727]                     {
  [07:07:08.727]                       inherits <- base::inherits
  [07:07:08.727]                       invokeRestart <- base::invokeRestart
  [07:07:08.727]                       muffled <- FALSE
  [07:07:08.727]                       if (inherits(cond, "message")) {
  [07:07:08.727]                         invokeRestart("muffleMessage")
  [07:07:08.727]                         muffled <- TRUE
  [07:07:08.727]                       }
  [07:07:08.727]                       else if (inherits(cond, "warning")) {
  [07:07:08.727]                         invokeRestart("muffleWarning")
  [07:07:08.727]                         muffled <- TRUE
  [07:07:08.727]                       }
  [07:07:08.727]                       else if (inherits(cond, "condition")) {
  [07:07:08.727]                         computeRestarts <- base::computeRestarts
  [07:07:08.727]                         grepl <- base::grepl
  [07:07:08.727]                         is.null <- base::is.null
  [07:07:08.727]                         restarts <- computeRestarts(cond)
  [07:07:08.727]                         for (restart in restarts) {
  [07:07:08.727]                           name <- restart$name
  [07:07:08.727]                           if (is.null(name)) 
  [07:07:08.727]                             next
  [07:07:08.727]                           if (!grepl("^muffle", name)) 
  [07:07:08.727]                             next
  [07:07:08.727]                           invokeRestart(restart)
  [07:07:08.727]                           muffled <- TRUE
  [07:07:08.727]                           break
  [07:07:08.727]                         }
  [07:07:08.727]                       }
  [07:07:08.727]                       invisible(muffled)
  [07:07:08.727]                     }
  [07:07:08.727]                     muffleCondition(cond)
  [07:07:08.727]                   }
  [07:07:08.727]                 }
  [07:07:08.727]             }
  [07:07:08.727]         }))
  [07:07:08.727]     }, error = function(ex) {
  [07:07:08.727]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.727]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.727]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.727]     }, finally = {
  [07:07:08.727]         {
  [07:07:08.727]             NULL
  [07:07:08.727]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.727]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.727]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.727]                 label = NULL, ...) 
  [07:07:08.727]             {
  [07:07:08.727]                 if (substitute) 
  [07:07:08.727]                   expr <- substitute(expr)
  [07:07:08.727]                 local <- as.logical(local)
  [07:07:08.727]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.727]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.727]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.727]                   label = label, ...)
  [07:07:08.727]                 if (!future$lazy) 
  [07:07:08.727]                   future <- run(future)
  [07:07:08.727]                 invisible(future)
  [07:07:08.727]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.727]         }
  [07:07:08.727]         base::options(...future.oldOptions)
  [07:07:08.727]     })
  [07:07:08.727]     Sys.time
  [07:07:08.727]     if (base::is.na(NA)) {
  [07:07:08.727]     }
  [07:07:08.727]     else {
  [07:07:08.727]         base::sink(type = "output", split = FALSE)
  [07:07:08.727]         if (NA) {
  [07:07:08.727]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.727]         }
  [07:07:08.727]         else {
  [07:07:08.727]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.727]         }
  [07:07:08.727]         base::close(...future.stdout)
  [07:07:08.727]         ...future.stdout <- NULL
  [07:07:08.727]     }
  [07:07:08.727]     ...future.result$conditions <- ...future.conditions
  [07:07:08.727]     ...future.result
  [07:07:08.727] }
  [07:07:08.737] plan(): Setting new future strategy stack:
  [07:07:08.742] List of future strategies:
  [07:07:08.742] 1. sequential:
  [07:07:08.742]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.742]    - tweaked: FALSE
  [07:07:08.742]    - call: NULL
  [07:07:08.746] plan(): nbrOfWorkers() = 1
  [07:07:08.753] Packages needed by the future expression (n = 0): <none>
  [07:07:08.756] Packages needed by future strategies (n = 0): <none>
  [07:07:08.767] {
  [07:07:08.767]     {
  [07:07:08.767]         ...future.startTime <- base::Sys.time()
  [07:07:08.767]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.767]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.767]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.767]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.767]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.767]         {
  [07:07:08.767]             {
  [07:07:08.767]                 base::local({
  [07:07:08.767]                   has_future <- base::requireNamespace("future", 
  [07:07:08.767]                     quietly = TRUE)
  [07:07:08.767]                   version <- if (has_future) 
  [07:07:08.767]                     utils::packageVersion("future")
  [07:07:08.767]                   else NULL
  [07:07:08.767]                   if (!has_future || version < "1.8.0") {
  [07:07:08.767]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.767]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.767]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.767]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.767]                         "release", "version")], collapse = " "), 
  [07:07:08.767]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.767]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.767]                       info)
  [07:07:08.767]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.767]                     if (!has_future) {
  [07:07:08.767]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.767]                         info)
  [07:07:08.767]                     }
  [07:07:08.767]                     else {
  [07:07:08.767]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.767]                         info, version)
  [07:07:08.767]                     }
  [07:07:08.767]                     base::stop(msg)
  [07:07:08.767]                   }
  [07:07:08.767]                 })
  [07:07:08.767]             }
  [07:07:08.767]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.767]         }
  [07:07:08.767]     }
  [07:07:08.767]     if (base::is.na(NA)) {
  [07:07:08.767]     }
  [07:07:08.767]     else {
  [07:07:08.767]         if (NA) {
  [07:07:08.767]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.767]                 open = "w")
  [07:07:08.767]         }
  [07:07:08.767]         else {
  [07:07:08.767]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.767]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.767]         }
  [07:07:08.767]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.767]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.767]             base::sink(type = "output", split = FALSE)
  [07:07:08.767]             base::close(...future.stdout)
  [07:07:08.767]         }, add = TRUE)
  [07:07:08.767]     }
  [07:07:08.767]     ...future.frame <- base::sys.nframe()
  [07:07:08.767]     ...future.conditions <- base::list()
  [07:07:08.767]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.767]     ...future.result <- base::tryCatch({
  [07:07:08.767]         base::withCallingHandlers({
  [07:07:08.767]             ...future.value <- base::withVisible(base::local({
  [07:07:08.767]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.767]             }))
  [07:07:08.767]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.767]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.767]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.767]                 version = "1.8")
  [07:07:08.767]         }, condition = base::local({
  [07:07:08.767]             c <- base::c
  [07:07:08.767]             inherits <- base::inherits
  [07:07:08.767]             invokeRestart <- base::invokeRestart
  [07:07:08.767]             length <- base::length
  [07:07:08.767]             list <- base::list
  [07:07:08.767]             seq.int <- base::seq.int
  [07:07:08.767]             signalCondition <- base::signalCondition
  [07:07:08.767]             sys.calls <- base::sys.calls
  [07:07:08.767]             Sys.time <- base::Sys.time
  [07:07:08.767]             `[[` <- base::`[[`
  [07:07:08.767]             `+` <- base::`+`
  [07:07:08.767]             `<<-` <- base::`<<-`
  [07:07:08.767]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.767]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.767]                   3L)]
  [07:07:08.767]             }
  [07:07:08.767]             function(cond) {
  [07:07:08.767]                 if (inherits(cond, "error")) {
  [07:07:08.767]                   sessionInformation <- function() {
  [07:07:08.767]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.767]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.767]                       search = base::search(), system = base::Sys.info())
  [07:07:08.767]                   }
  [07:07:08.767]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.767]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.767]                     cond$call), session = sessionInformation(), 
  [07:07:08.767]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.767]                   signalCondition(cond)
  [07:07:08.767]                 }
  [07:07:08.767]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.767]                 ))) {
  [07:07:08.767]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.767]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.767]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.767]                   if (!signal) {
  [07:07:08.767]                     muffleCondition <- function (cond) 
  [07:07:08.767]                     {
  [07:07:08.767]                       inherits <- base::inherits
  [07:07:08.767]                       invokeRestart <- base::invokeRestart
  [07:07:08.767]                       muffled <- FALSE
  [07:07:08.767]                       if (inherits(cond, "message")) {
  [07:07:08.767]                         invokeRestart("muffleMessage")
  [07:07:08.767]                         muffled <- TRUE
  [07:07:08.767]                       }
  [07:07:08.767]                       else if (inherits(cond, "warning")) {
  [07:07:08.767]                         invokeRestart("muffleWarning")
  [07:07:08.767]                         muffled <- TRUE
  [07:07:08.767]                       }
  [07:07:08.767]                       else if (inherits(cond, "condition")) {
  [07:07:08.767]                         computeRestarts <- base::computeRestarts
  [07:07:08.767]                         grepl <- base::grepl
  [07:07:08.767]                         is.null <- base::is.null
  [07:07:08.767]                         restarts <- computeRestarts(cond)
  [07:07:08.767]                         for (restart in restarts) {
  [07:07:08.767]                           name <- restart$name
  [07:07:08.767]                           if (is.null(name)) 
  [07:07:08.767]                             next
  [07:07:08.767]                           if (!grepl("^muffle", name)) 
  [07:07:08.767]                             next
  [07:07:08.767]                           invokeRestart(restart)
  [07:07:08.767]                           muffled <- TRUE
  [07:07:08.767]                           break
  [07:07:08.767]                         }
  [07:07:08.767]                       }
  [07:07:08.767]                       invisible(muffled)
  [07:07:08.767]                     }
  [07:07:08.767]                     muffleCondition(cond)
  [07:07:08.767]                   }
  [07:07:08.767]                 }
  [07:07:08.767]             }
  [07:07:08.767]         }))
  [07:07:08.767]     }, error = function(ex) {
  [07:07:08.767]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.767]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.767]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.767]     }, finally = {
  [07:07:08.767]         {
  [07:07:08.767]             NULL
  [07:07:08.767]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.767]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.767]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.767]                 label = NULL, ...) 
  [07:07:08.767]             {
  [07:07:08.767]                 if (substitute) 
  [07:07:08.767]                   expr <- substitute(expr)
  [07:07:08.767]                 local <- as.logical(local)
  [07:07:08.767]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.767]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.767]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.767]                   label = label, ...)
  [07:07:08.767]                 if (!future$lazy) 
  [07:07:08.767]                   future <- run(future)
  [07:07:08.767]                 invisible(future)
  [07:07:08.767]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.767]         }
  [07:07:08.767]         base::options(...future.oldOptions)
  [07:07:08.767]     })
  [07:07:08.767]     Sys.time
  [07:07:08.767]     if (base::is.na(NA)) {
  [07:07:08.767]     }
  [07:07:08.767]     else {
  [07:07:08.767]         base::sink(type = "output", split = FALSE)
  [07:07:08.767]         if (NA) {
  [07:07:08.767]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.767]         }
  [07:07:08.767]         else {
  [07:07:08.767]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.767]         }
  [07:07:08.767]         base::close(...future.stdout)
  [07:07:08.767]         ...future.stdout <- NULL
  [07:07:08.767]     }
  [07:07:08.767]     ...future.result$conditions <- ...future.conditions
  [07:07:08.767]     ...future.result
  [07:07:08.767] }
  [07:07:08.777] plan(): Setting new future strategy stack:
  [07:07:08.781] List of future strategies:
  [07:07:08.781] 1. sequential:
  [07:07:08.781]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.781]    - tweaked: FALSE
  [07:07:08.781]    - call: NULL
  [07:07:08.785] plan(): nbrOfWorkers() = 1
  [07:07:08.796] Packages needed by the future expression (n = 0): <none>
  [07:07:08.799] Packages needed by future strategies (n = 0): <none>
  [07:07:08.811] {
  [07:07:08.811]     {
  [07:07:08.811]         ...future.startTime <- base::Sys.time()
  [07:07:08.811]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.811]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.811]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.811]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.811]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.811]         {
  [07:07:08.811]             {
  [07:07:08.811]                 base::local({
  [07:07:08.811]                   has_future <- base::requireNamespace("future", 
  [07:07:08.811]                     quietly = TRUE)
  [07:07:08.811]                   version <- if (has_future) 
  [07:07:08.811]                     utils::packageVersion("future")
  [07:07:08.811]                   else NULL
  [07:07:08.811]                   if (!has_future || version < "1.8.0") {
  [07:07:08.811]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.811]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.811]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.811]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.811]                         "release", "version")], collapse = " "), 
  [07:07:08.811]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.811]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.811]                       info)
  [07:07:08.811]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.811]                     if (!has_future) {
  [07:07:08.811]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.811]                         info)
  [07:07:08.811]                     }
  [07:07:08.811]                     else {
  [07:07:08.811]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.811]                         info, version)
  [07:07:08.811]                     }
  [07:07:08.811]                     base::stop(msg)
  [07:07:08.811]                   }
  [07:07:08.811]                 })
  [07:07:08.811]             }
  [07:07:08.811]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.811]         }
  [07:07:08.811]     }
  [07:07:08.811]     if (base::is.na(NA)) {
  [07:07:08.811]     }
  [07:07:08.811]     else {
  [07:07:08.811]         if (NA) {
  [07:07:08.811]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.811]                 open = "w")
  [07:07:08.811]         }
  [07:07:08.811]         else {
  [07:07:08.811]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.811]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.811]         }
  [07:07:08.811]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.811]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.811]             base::sink(type = "output", split = FALSE)
  [07:07:08.811]             base::close(...future.stdout)
  [07:07:08.811]         }, add = TRUE)
  [07:07:08.811]     }
  [07:07:08.811]     ...future.frame <- base::sys.nframe()
  [07:07:08.811]     ...future.conditions <- base::list()
  [07:07:08.811]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.811]     ...future.result <- base::tryCatch({
  [07:07:08.811]         base::withCallingHandlers({
  [07:07:08.811]             ...future.value <- base::withVisible(base::local({
  [07:07:08.811]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.811]             }))
  [07:07:08.811]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.811]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.811]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.811]                 version = "1.8")
  [07:07:08.811]         }, condition = base::local({
  [07:07:08.811]             c <- base::c
  [07:07:08.811]             inherits <- base::inherits
  [07:07:08.811]             invokeRestart <- base::invokeRestart
  [07:07:08.811]             length <- base::length
  [07:07:08.811]             list <- base::list
  [07:07:08.811]             seq.int <- base::seq.int
  [07:07:08.811]             signalCondition <- base::signalCondition
  [07:07:08.811]             sys.calls <- base::sys.calls
  [07:07:08.811]             Sys.time <- base::Sys.time
  [07:07:08.811]             `[[` <- base::`[[`
  [07:07:08.811]             `+` <- base::`+`
  [07:07:08.811]             `<<-` <- base::`<<-`
  [07:07:08.811]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.811]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.811]                   3L)]
  [07:07:08.811]             }
  [07:07:08.811]             function(cond) {
  [07:07:08.811]                 if (inherits(cond, "error")) {
  [07:07:08.811]                   sessionInformation <- function() {
  [07:07:08.811]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.811]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.811]                       search = base::search(), system = base::Sys.info())
  [07:07:08.811]                   }
  [07:07:08.811]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.811]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.811]                     cond$call), session = sessionInformation(), 
  [07:07:08.811]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.811]                   signalCondition(cond)
  [07:07:08.811]                 }
  [07:07:08.811]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.811]                 ))) {
  [07:07:08.811]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.811]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.811]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.811]                   if (!signal) {
  [07:07:08.811]                     muffleCondition <- function (cond) 
  [07:07:08.811]                     {
  [07:07:08.811]                       inherits <- base::inherits
  [07:07:08.811]                       invokeRestart <- base::invokeRestart
  [07:07:08.811]                       muffled <- FALSE
  [07:07:08.811]                       if (inherits(cond, "message")) {
  [07:07:08.811]                         invokeRestart("muffleMessage")
  [07:07:08.811]                         muffled <- TRUE
  [07:07:08.811]                       }
  [07:07:08.811]                       else if (inherits(cond, "warning")) {
  [07:07:08.811]                         invokeRestart("muffleWarning")
  [07:07:08.811]                         muffled <- TRUE
  [07:07:08.811]                       }
  [07:07:08.811]                       else if (inherits(cond, "condition")) {
  [07:07:08.811]                         computeRestarts <- base::computeRestarts
  [07:07:08.811]                         grepl <- base::grepl
  [07:07:08.811]                         is.null <- base::is.null
  [07:07:08.811]                         restarts <- computeRestarts(cond)
  [07:07:08.811]                         for (restart in restarts) {
  [07:07:08.811]                           name <- restart$name
  [07:07:08.811]                           if (is.null(name)) 
  [07:07:08.811]                             next
  [07:07:08.811]                           if (!grepl("^muffle", name)) 
  [07:07:08.811]                             next
  [07:07:08.811]                           invokeRestart(restart)
  [07:07:08.811]                           muffled <- TRUE
  [07:07:08.811]                           break
  [07:07:08.811]                         }
  [07:07:08.811]                       }
  [07:07:08.811]                       invisible(muffled)
  [07:07:08.811]                     }
  [07:07:08.811]                     muffleCondition(cond)
  [07:07:08.811]                   }
  [07:07:08.811]                 }
  [07:07:08.811]             }
  [07:07:08.811]         }))
  [07:07:08.811]     }, error = function(ex) {
  [07:07:08.811]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.811]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.811]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.811]     }, finally = {
  [07:07:08.811]         {
  [07:07:08.811]             NULL
  [07:07:08.811]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.811]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.811]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.811]                 label = NULL, ...) 
  [07:07:08.811]             {
  [07:07:08.811]                 if (substitute) 
  [07:07:08.811]                   expr <- substitute(expr)
  [07:07:08.811]                 local <- as.logical(local)
  [07:07:08.811]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.811]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.811]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.811]                   label = label, ...)
  [07:07:08.811]                 if (!future$lazy) 
  [07:07:08.811]                   future <- run(future)
  [07:07:08.811]                 invisible(future)
  [07:07:08.811]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.811]         }
  [07:07:08.811]         base::options(...future.oldOptions)
  [07:07:08.811]     })
  [07:07:08.811]     Sys.time
  [07:07:08.811]     if (base::is.na(NA)) {
  [07:07:08.811]     }
  [07:07:08.811]     else {
  [07:07:08.811]         base::sink(type = "output", split = FALSE)
  [07:07:08.811]         if (NA) {
  [07:07:08.811]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.811]         }
  [07:07:08.811]         else {
  [07:07:08.811]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.811]         }
  [07:07:08.811]         base::close(...future.stdout)
  [07:07:08.811]         ...future.stdout <- NULL
  [07:07:08.811]     }
  [07:07:08.811]     ...future.result$conditions <- ...future.conditions
  [07:07:08.811]     ...future.result
  [07:07:08.811] }
  [07:07:08.821] plan(): Setting new future strategy stack:
  [07:07:08.825] List of future strategies:
  [07:07:08.825] 1. sequential:
  [07:07:08.825]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.825]    - tweaked: FALSE
  [07:07:08.825]    - call: NULL
  [07:07:08.829] plan(): nbrOfWorkers() = 1
  [07:07:08.836] Packages needed by the future expression (n = 0): <none>
  [07:07:08.840] Packages needed by future strategies (n = 0): <none>
  [07:07:08.851] {
  [07:07:08.851]     {
  [07:07:08.851]         ...future.startTime <- base::Sys.time()
  [07:07:08.851]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.851]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.851]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.851]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.851]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.851]         {
  [07:07:08.851]             {
  [07:07:08.851]                 base::local({
  [07:07:08.851]                   has_future <- base::requireNamespace("future", 
  [07:07:08.851]                     quietly = TRUE)
  [07:07:08.851]                   version <- if (has_future) 
  [07:07:08.851]                     utils::packageVersion("future")
  [07:07:08.851]                   else NULL
  [07:07:08.851]                   if (!has_future || version < "1.8.0") {
  [07:07:08.851]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.851]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.851]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.851]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.851]                         "release", "version")], collapse = " "), 
  [07:07:08.851]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.851]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.851]                       info)
  [07:07:08.851]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.851]                     if (!has_future) {
  [07:07:08.851]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.851]                         info)
  [07:07:08.851]                     }
  [07:07:08.851]                     else {
  [07:07:08.851]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.851]                         info, version)
  [07:07:08.851]                     }
  [07:07:08.851]                     base::stop(msg)
  [07:07:08.851]                   }
  [07:07:08.851]                 })
  [07:07:08.851]             }
  [07:07:08.851]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.851]         }
  [07:07:08.851]     }
  [07:07:08.851]     if (base::is.na(NA)) {
  [07:07:08.851]     }
  [07:07:08.851]     else {
  [07:07:08.851]         if (NA) {
  [07:07:08.851]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.851]                 open = "w")
  [07:07:08.851]         }
  [07:07:08.851]         else {
  [07:07:08.851]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.851]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.851]         }
  [07:07:08.851]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.851]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.851]             base::sink(type = "output", split = FALSE)
  [07:07:08.851]             base::close(...future.stdout)
  [07:07:08.851]         }, add = TRUE)
  [07:07:08.851]     }
  [07:07:08.851]     ...future.frame <- base::sys.nframe()
  [07:07:08.851]     ...future.conditions <- base::list()
  [07:07:08.851]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.851]     ...future.result <- base::tryCatch({
  [07:07:08.851]         base::withCallingHandlers({
  [07:07:08.851]             ...future.value <- base::withVisible(base::local({
  [07:07:08.851]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.851]             }))
  [07:07:08.851]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.851]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.851]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.851]                 version = "1.8")
  [07:07:08.851]         }, condition = base::local({
  [07:07:08.851]             c <- base::c
  [07:07:08.851]             inherits <- base::inherits
  [07:07:08.851]             invokeRestart <- base::invokeRestart
  [07:07:08.851]             length <- base::length
  [07:07:08.851]             list <- base::list
  [07:07:08.851]             seq.int <- base::seq.int
  [07:07:08.851]             signalCondition <- base::signalCondition
  [07:07:08.851]             sys.calls <- base::sys.calls
  [07:07:08.851]             Sys.time <- base::Sys.time
  [07:07:08.851]             `[[` <- base::`[[`
  [07:07:08.851]             `+` <- base::`+`
  [07:07:08.851]             `<<-` <- base::`<<-`
  [07:07:08.851]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.851]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.851]                   3L)]
  [07:07:08.851]             }
  [07:07:08.851]             function(cond) {
  [07:07:08.851]                 if (inherits(cond, "error")) {
  [07:07:08.851]                   sessionInformation <- function() {
  [07:07:08.851]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.851]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.851]                       search = base::search(), system = base::Sys.info())
  [07:07:08.851]                   }
  [07:07:08.851]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.851]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.851]                     cond$call), session = sessionInformation(), 
  [07:07:08.851]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.851]                   signalCondition(cond)
  [07:07:08.851]                 }
  [07:07:08.851]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.851]                 ))) {
  [07:07:08.851]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.851]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.851]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.851]                   if (!signal) {
  [07:07:08.851]                     muffleCondition <- function (cond) 
  [07:07:08.851]                     {
  [07:07:08.851]                       inherits <- base::inherits
  [07:07:08.851]                       invokeRestart <- base::invokeRestart
  [07:07:08.851]                       muffled <- FALSE
  [07:07:08.851]                       if (inherits(cond, "message")) {
  [07:07:08.851]                         invokeRestart("muffleMessage")
  [07:07:08.851]                         muffled <- TRUE
  [07:07:08.851]                       }
  [07:07:08.851]                       else if (inherits(cond, "warning")) {
  [07:07:08.851]                         invokeRestart("muffleWarning")
  [07:07:08.851]                         muffled <- TRUE
  [07:07:08.851]                       }
  [07:07:08.851]                       else if (inherits(cond, "condition")) {
  [07:07:08.851]                         computeRestarts <- base::computeRestarts
  [07:07:08.851]                         grepl <- base::grepl
  [07:07:08.851]                         is.null <- base::is.null
  [07:07:08.851]                         restarts <- computeRestarts(cond)
  [07:07:08.851]                         for (restart in restarts) {
  [07:07:08.851]                           name <- restart$name
  [07:07:08.851]                           if (is.null(name)) 
  [07:07:08.851]                             next
  [07:07:08.851]                           if (!grepl("^muffle", name)) 
  [07:07:08.851]                             next
  [07:07:08.851]                           invokeRestart(restart)
  [07:07:08.851]                           muffled <- TRUE
  [07:07:08.851]                           break
  [07:07:08.851]                         }
  [07:07:08.851]                       }
  [07:07:08.851]                       invisible(muffled)
  [07:07:08.851]                     }
  [07:07:08.851]                     muffleCondition(cond)
  [07:07:08.851]                   }
  [07:07:08.851]                 }
  [07:07:08.851]             }
  [07:07:08.851]         }))
  [07:07:08.851]     }, error = function(ex) {
  [07:07:08.851]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.851]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.851]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.851]     }, finally = {
  [07:07:08.851]         {
  [07:07:08.851]             NULL
  [07:07:08.851]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.851]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.851]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.851]                 label = NULL, ...) 
  [07:07:08.851]             {
  [07:07:08.851]                 if (substitute) 
  [07:07:08.851]                   expr <- substitute(expr)
  [07:07:08.851]                 local <- as.logical(local)
  [07:07:08.851]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.851]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.851]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.851]                   label = label, ...)
  [07:07:08.851]                 if (!future$lazy) 
  [07:07:08.851]                   future <- run(future)
  [07:07:08.851]                 invisible(future)
  [07:07:08.851]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.851]         }
  [07:07:08.851]         base::options(...future.oldOptions)
  [07:07:08.851]     })
  [07:07:08.851]     Sys.time
  [07:07:08.851]     if (base::is.na(NA)) {
  [07:07:08.851]     }
  [07:07:08.851]     else {
  [07:07:08.851]         base::sink(type = "output", split = FALSE)
  [07:07:08.851]         if (NA) {
  [07:07:08.851]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.851]         }
  [07:07:08.851]         else {
  [07:07:08.851]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.851]         }
  [07:07:08.851]         base::close(...future.stdout)
  [07:07:08.851]         ...future.stdout <- NULL
  [07:07:08.851]     }
  [07:07:08.851]     ...future.result$conditions <- ...future.conditions
  [07:07:08.851]     ...future.result
  [07:07:08.851] }
  [07:07:08.862] plan(): Setting new future strategy stack:
  [07:07:08.866] List of future strategies:
  [07:07:08.866] 1. sequential:
  [07:07:08.866]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.866]    - tweaked: FALSE
  [07:07:08.866]    - call: NULL
  [07:07:08.871] plan(): nbrOfWorkers() = 1
  [07:07:08.878] Packages needed by the future expression (n = 0): <none>
  [07:07:08.882] Packages needed by future strategies (n = 0): <none>
  [07:07:08.894] {
  [07:07:08.894]     {
  [07:07:08.894]         ...future.startTime <- base::Sys.time()
  [07:07:08.894]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.894]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.894]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.894]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.894]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.894]         {
  [07:07:08.894]             {
  [07:07:08.894]                 base::local({
  [07:07:08.894]                   has_future <- base::requireNamespace("future", 
  [07:07:08.894]                     quietly = TRUE)
  [07:07:08.894]                   version <- if (has_future) 
  [07:07:08.894]                     utils::packageVersion("future")
  [07:07:08.894]                   else NULL
  [07:07:08.894]                   if (!has_future || version < "1.8.0") {
  [07:07:08.894]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.894]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.894]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.894]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.894]                         "release", "version")], collapse = " "), 
  [07:07:08.894]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.894]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.894]                       info)
  [07:07:08.894]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.894]                     if (!has_future) {
  [07:07:08.894]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.894]                         info)
  [07:07:08.894]                     }
  [07:07:08.894]                     else {
  [07:07:08.894]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.894]                         info, version)
  [07:07:08.894]                     }
  [07:07:08.894]                     base::stop(msg)
  [07:07:08.894]                   }
  [07:07:08.894]                 })
  [07:07:08.894]             }
  [07:07:08.894]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.894]         }
  [07:07:08.894]     }
  [07:07:08.894]     if (base::is.na(NA)) {
  [07:07:08.894]     }
  [07:07:08.894]     else {
  [07:07:08.894]         if (NA) {
  [07:07:08.894]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.894]                 open = "w")
  [07:07:08.894]         }
  [07:07:08.894]         else {
  [07:07:08.894]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.894]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.894]         }
  [07:07:08.894]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.894]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.894]             base::sink(type = "output", split = FALSE)
  [07:07:08.894]             base::close(...future.stdout)
  [07:07:08.894]         }, add = TRUE)
  [07:07:08.894]     }
  [07:07:08.894]     ...future.frame <- base::sys.nframe()
  [07:07:08.894]     ...future.conditions <- base::list()
  [07:07:08.894]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.894]     ...future.result <- base::tryCatch({
  [07:07:08.894]         base::withCallingHandlers({
  [07:07:08.894]             ...future.value <- base::withVisible(base::local({
  [07:07:08.894]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.894]             }))
  [07:07:08.894]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.894]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.894]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.894]                 version = "1.8")
  [07:07:08.894]         }, condition = base::local({
  [07:07:08.894]             c <- base::c
  [07:07:08.894]             inherits <- base::inherits
  [07:07:08.894]             invokeRestart <- base::invokeRestart
  [07:07:08.894]             length <- base::length
  [07:07:08.894]             list <- base::list
  [07:07:08.894]             seq.int <- base::seq.int
  [07:07:08.894]             signalCondition <- base::signalCondition
  [07:07:08.894]             sys.calls <- base::sys.calls
  [07:07:08.894]             Sys.time <- base::Sys.time
  [07:07:08.894]             `[[` <- base::`[[`
  [07:07:08.894]             `+` <- base::`+`
  [07:07:08.894]             `<<-` <- base::`<<-`
  [07:07:08.894]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.894]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.894]                   3L)]
  [07:07:08.894]             }
  [07:07:08.894]             function(cond) {
  [07:07:08.894]                 if (inherits(cond, "error")) {
  [07:07:08.894]                   sessionInformation <- function() {
  [07:07:08.894]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.894]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.894]                       search = base::search(), system = base::Sys.info())
  [07:07:08.894]                   }
  [07:07:08.894]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.894]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.894]                     cond$call), session = sessionInformation(), 
  [07:07:08.894]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.894]                   signalCondition(cond)
  [07:07:08.894]                 }
  [07:07:08.894]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.894]                 ))) {
  [07:07:08.894]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.894]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.894]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.894]                   if (!signal) {
  [07:07:08.894]                     muffleCondition <- function (cond) 
  [07:07:08.894]                     {
  [07:07:08.894]                       inherits <- base::inherits
  [07:07:08.894]                       invokeRestart <- base::invokeRestart
  [07:07:08.894]                       muffled <- FALSE
  [07:07:08.894]                       if (inherits(cond, "message")) {
  [07:07:08.894]                         invokeRestart("muffleMessage")
  [07:07:08.894]                         muffled <- TRUE
  [07:07:08.894]                       }
  [07:07:08.894]                       else if (inherits(cond, "warning")) {
  [07:07:08.894]                         invokeRestart("muffleWarning")
  [07:07:08.894]                         muffled <- TRUE
  [07:07:08.894]                       }
  [07:07:08.894]                       else if (inherits(cond, "condition")) {
  [07:07:08.894]                         computeRestarts <- base::computeRestarts
  [07:07:08.894]                         grepl <- base::grepl
  [07:07:08.894]                         is.null <- base::is.null
  [07:07:08.894]                         restarts <- computeRestarts(cond)
  [07:07:08.894]                         for (restart in restarts) {
  [07:07:08.894]                           name <- restart$name
  [07:07:08.894]                           if (is.null(name)) 
  [07:07:08.894]                             next
  [07:07:08.894]                           if (!grepl("^muffle", name)) 
  [07:07:08.894]                             next
  [07:07:08.894]                           invokeRestart(restart)
  [07:07:08.894]                           muffled <- TRUE
  [07:07:08.894]                           break
  [07:07:08.894]                         }
  [07:07:08.894]                       }
  [07:07:08.894]                       invisible(muffled)
  [07:07:08.894]                     }
  [07:07:08.894]                     muffleCondition(cond)
  [07:07:08.894]                   }
  [07:07:08.894]                 }
  [07:07:08.894]             }
  [07:07:08.894]         }))
  [07:07:08.894]     }, error = function(ex) {
  [07:07:08.894]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.894]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.894]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.894]     }, finally = {
  [07:07:08.894]         {
  [07:07:08.894]             NULL
  [07:07:08.894]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.894]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.894]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.894]                 label = NULL, ...) 
  [07:07:08.894]             {
  [07:07:08.894]                 if (substitute) 
  [07:07:08.894]                   expr <- substitute(expr)
  [07:07:08.894]                 local <- as.logical(local)
  [07:07:08.894]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.894]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.894]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.894]                   label = label, ...)
  [07:07:08.894]                 if (!future$lazy) 
  [07:07:08.894]                   future <- run(future)
  [07:07:08.894]                 invisible(future)
  [07:07:08.894]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.894]         }
  [07:07:08.894]         base::options(...future.oldOptions)
  [07:07:08.894]     })
  [07:07:08.894]     Sys.time
  [07:07:08.894]     if (base::is.na(NA)) {
  [07:07:08.894]     }
  [07:07:08.894]     else {
  [07:07:08.894]         base::sink(type = "output", split = FALSE)
  [07:07:08.894]         if (NA) {
  [07:07:08.894]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.894]         }
  [07:07:08.894]         else {
  [07:07:08.894]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.894]         }
  [07:07:08.894]         base::close(...future.stdout)
  [07:07:08.894]         ...future.stdout <- NULL
  [07:07:08.894]     }
  [07:07:08.894]     ...future.result$conditions <- ...future.conditions
  [07:07:08.894]     ...future.result
  [07:07:08.894] }
  [07:07:08.905] plan(): Setting new future strategy stack:
  [07:07:08.908] List of future strategies:
  [07:07:08.908] 1. sequential:
  [07:07:08.908]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.908]    - tweaked: FALSE
  [07:07:08.908]    - call: NULL
  [07:07:08.913] plan(): nbrOfWorkers() = 1
  [07:07:08.920] Packages needed by the future expression (n = 0): <none>
  [07:07:08.924] Packages needed by future strategies (n = 0): <none>
  [07:07:08.935] {
  [07:07:08.935]     {
  [07:07:08.935]         ...future.startTime <- base::Sys.time()
  [07:07:08.935]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.935]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.935]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.935]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.935]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.935]         {
  [07:07:08.935]             {
  [07:07:08.935]                 base::local({
  [07:07:08.935]                   has_future <- base::requireNamespace("future", 
  [07:07:08.935]                     quietly = TRUE)
  [07:07:08.935]                   version <- if (has_future) 
  [07:07:08.935]                     utils::packageVersion("future")
  [07:07:08.935]                   else NULL
  [07:07:08.935]                   if (!has_future || version < "1.8.0") {
  [07:07:08.935]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.935]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.935]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.935]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.935]                         "release", "version")], collapse = " "), 
  [07:07:08.935]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.935]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.935]                       info)
  [07:07:08.935]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.935]                     if (!has_future) {
  [07:07:08.935]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.935]                         info)
  [07:07:08.935]                     }
  [07:07:08.935]                     else {
  [07:07:08.935]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.935]                         info, version)
  [07:07:08.935]                     }
  [07:07:08.935]                     base::stop(msg)
  [07:07:08.935]                   }
  [07:07:08.935]                 })
  [07:07:08.935]             }
  [07:07:08.935]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.935]         }
  [07:07:08.935]     }
  [07:07:08.935]     if (base::is.na(NA)) {
  [07:07:08.935]     }
  [07:07:08.935]     else {
  [07:07:08.935]         if (NA) {
  [07:07:08.935]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.935]                 open = "w")
  [07:07:08.935]         }
  [07:07:08.935]         else {
  [07:07:08.935]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.935]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.935]         }
  [07:07:08.935]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.935]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.935]             base::sink(type = "output", split = FALSE)
  [07:07:08.935]             base::close(...future.stdout)
  [07:07:08.935]         }, add = TRUE)
  [07:07:08.935]     }
  [07:07:08.935]     ...future.frame <- base::sys.nframe()
  [07:07:08.935]     ...future.conditions <- base::list()
  [07:07:08.935]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.935]     ...future.result <- base::tryCatch({
  [07:07:08.935]         base::withCallingHandlers({
  [07:07:08.935]             ...future.value <- base::withVisible(base::local({
  [07:07:08.935]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.935]             }))
  [07:07:08.935]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.935]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.935]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.935]                 version = "1.8")
  [07:07:08.935]         }, condition = base::local({
  [07:07:08.935]             c <- base::c
  [07:07:08.935]             inherits <- base::inherits
  [07:07:08.935]             invokeRestart <- base::invokeRestart
  [07:07:08.935]             length <- base::length
  [07:07:08.935]             list <- base::list
  [07:07:08.935]             seq.int <- base::seq.int
  [07:07:08.935]             signalCondition <- base::signalCondition
  [07:07:08.935]             sys.calls <- base::sys.calls
  [07:07:08.935]             Sys.time <- base::Sys.time
  [07:07:08.935]             `[[` <- base::`[[`
  [07:07:08.935]             `+` <- base::`+`
  [07:07:08.935]             `<<-` <- base::`<<-`
  [07:07:08.935]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.935]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.935]                   3L)]
  [07:07:08.935]             }
  [07:07:08.935]             function(cond) {
  [07:07:08.935]                 if (inherits(cond, "error")) {
  [07:07:08.935]                   sessionInformation <- function() {
  [07:07:08.935]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.935]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.935]                       search = base::search(), system = base::Sys.info())
  [07:07:08.935]                   }
  [07:07:08.935]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.935]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.935]                     cond$call), session = sessionInformation(), 
  [07:07:08.935]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.935]                   signalCondition(cond)
  [07:07:08.935]                 }
  [07:07:08.935]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.935]                 ))) {
  [07:07:08.935]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.935]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.935]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.935]                   if (!signal) {
  [07:07:08.935]                     muffleCondition <- function (cond) 
  [07:07:08.935]                     {
  [07:07:08.935]                       inherits <- base::inherits
  [07:07:08.935]                       invokeRestart <- base::invokeRestart
  [07:07:08.935]                       muffled <- FALSE
  [07:07:08.935]                       if (inherits(cond, "message")) {
  [07:07:08.935]                         invokeRestart("muffleMessage")
  [07:07:08.935]                         muffled <- TRUE
  [07:07:08.935]                       }
  [07:07:08.935]                       else if (inherits(cond, "warning")) {
  [07:07:08.935]                         invokeRestart("muffleWarning")
  [07:07:08.935]                         muffled <- TRUE
  [07:07:08.935]                       }
  [07:07:08.935]                       else if (inherits(cond, "condition")) {
  [07:07:08.935]                         computeRestarts <- base::computeRestarts
  [07:07:08.935]                         grepl <- base::grepl
  [07:07:08.935]                         is.null <- base::is.null
  [07:07:08.935]                         restarts <- computeRestarts(cond)
  [07:07:08.935]                         for (restart in restarts) {
  [07:07:08.935]                           name <- restart$name
  [07:07:08.935]                           if (is.null(name)) 
  [07:07:08.935]                             next
  [07:07:08.935]                           if (!grepl("^muffle", name)) 
  [07:07:08.935]                             next
  [07:07:08.935]                           invokeRestart(restart)
  [07:07:08.935]                           muffled <- TRUE
  [07:07:08.935]                           break
  [07:07:08.935]                         }
  [07:07:08.935]                       }
  [07:07:08.935]                       invisible(muffled)
  [07:07:08.935]                     }
  [07:07:08.935]                     muffleCondition(cond)
  [07:07:08.935]                   }
  [07:07:08.935]                 }
  [07:07:08.935]             }
  [07:07:08.935]         }))
  [07:07:08.935]     }, error = function(ex) {
  [07:07:08.935]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.935]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.935]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.935]     }, finally = {
  [07:07:08.935]         {
  [07:07:08.935]             NULL
  [07:07:08.935]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.935]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.935]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.935]                 label = NULL, ...) 
  [07:07:08.935]             {
  [07:07:08.935]                 if (substitute) 
  [07:07:08.935]                   expr <- substitute(expr)
  [07:07:08.935]                 local <- as.logical(local)
  [07:07:08.935]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.935]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.935]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.935]                   label = label, ...)
  [07:07:08.935]                 if (!future$lazy) 
  [07:07:08.935]                   future <- run(future)
  [07:07:08.935]                 invisible(future)
  [07:07:08.935]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.935]         }
  [07:07:08.935]         base::options(...future.oldOptions)
  [07:07:08.935]     })
  [07:07:08.935]     Sys.time
  [07:07:08.935]     if (base::is.na(NA)) {
  [07:07:08.935]     }
  [07:07:08.935]     else {
  [07:07:08.935]         base::sink(type = "output", split = FALSE)
  [07:07:08.935]         if (NA) {
  [07:07:08.935]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.935]         }
  [07:07:08.935]         else {
  [07:07:08.935]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.935]         }
  [07:07:08.935]         base::close(...future.stdout)
  [07:07:08.935]         ...future.stdout <- NULL
  [07:07:08.935]     }
  [07:07:08.935]     ...future.result$conditions <- ...future.conditions
  [07:07:08.935]     ...future.result
  [07:07:08.935] }
  [07:07:08.951] plan(): Setting new future strategy stack:
  [07:07:08.955] List of future strategies:
  [07:07:08.955] 1. sequential:
  [07:07:08.955]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:08.955]    - tweaked: FALSE
  [07:07:08.955]    - call: NULL
  [07:07:08.961] plan(): nbrOfWorkers() = 1
  [07:07:08.968] Packages needed by the future expression (n = 0): <none>
  [07:07:08.973] Packages needed by future strategies (n = 0): <none>
  [07:07:08.985] {
  [07:07:08.985]     {
  [07:07:08.985]         ...future.startTime <- base::Sys.time()
  [07:07:08.985]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:08.985]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:08.985]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:08.985]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:08.985]             future.resolve.recursive = NULL, width = 80L)
  [07:07:08.985]         {
  [07:07:08.985]             {
  [07:07:08.985]                 base::local({
  [07:07:08.985]                   has_future <- base::requireNamespace("future", 
  [07:07:08.985]                     quietly = TRUE)
  [07:07:08.985]                   version <- if (has_future) 
  [07:07:08.985]                     utils::packageVersion("future")
  [07:07:08.985]                   else NULL
  [07:07:08.985]                   if (!has_future || version < "1.8.0") {
  [07:07:08.985]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:08.985]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:08.985]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:08.985]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:08.985]                         "release", "version")], collapse = " "), 
  [07:07:08.985]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:08.985]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:08.985]                       info)
  [07:07:08.985]                     info <- base::paste(info, collapse = "; ")
  [07:07:08.985]                     if (!has_future) {
  [07:07:08.985]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:08.985]                         info)
  [07:07:08.985]                     }
  [07:07:08.985]                     else {
  [07:07:08.985]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:08.985]                         info, version)
  [07:07:08.985]                     }
  [07:07:08.985]                     base::stop(msg)
  [07:07:08.985]                   }
  [07:07:08.985]                 })
  [07:07:08.985]             }
  [07:07:08.985]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:08.985]         }
  [07:07:08.985]     }
  [07:07:08.985]     if (base::is.na(NA)) {
  [07:07:08.985]     }
  [07:07:08.985]     else {
  [07:07:08.985]         if (NA) {
  [07:07:08.985]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:08.985]                 open = "w")
  [07:07:08.985]         }
  [07:07:08.985]         else {
  [07:07:08.985]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:08.985]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:08.985]         }
  [07:07:08.985]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:08.985]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:08.985]             base::sink(type = "output", split = FALSE)
  [07:07:08.985]             base::close(...future.stdout)
  [07:07:08.985]         }, add = TRUE)
  [07:07:08.985]     }
  [07:07:08.985]     ...future.frame <- base::sys.nframe()
  [07:07:08.985]     ...future.conditions <- base::list()
  [07:07:08.985]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:08.985]     ...future.result <- base::tryCatch({
  [07:07:08.985]         base::withCallingHandlers({
  [07:07:08.985]             ...future.value <- base::withVisible(base::local({
  [07:07:08.985]                 x[[i - 2]] + x[[i - 1]]
  [07:07:08.985]             }))
  [07:07:08.985]             future::FutureResult(value = ...future.value$value, 
  [07:07:08.985]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.985]                   ...future.rng), started = ...future.startTime, 
  [07:07:08.985]                 version = "1.8")
  [07:07:08.985]         }, condition = base::local({
  [07:07:08.985]             c <- base::c
  [07:07:08.985]             inherits <- base::inherits
  [07:07:08.985]             invokeRestart <- base::invokeRestart
  [07:07:08.985]             length <- base::length
  [07:07:08.985]             list <- base::list
  [07:07:08.985]             seq.int <- base::seq.int
  [07:07:08.985]             signalCondition <- base::signalCondition
  [07:07:08.985]             sys.calls <- base::sys.calls
  [07:07:08.985]             Sys.time <- base::Sys.time
  [07:07:08.985]             `[[` <- base::`[[`
  [07:07:08.985]             `+` <- base::`+`
  [07:07:08.985]             `<<-` <- base::`<<-`
  [07:07:08.985]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:08.985]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:08.985]                   3L)]
  [07:07:08.985]             }
  [07:07:08.985]             function(cond) {
  [07:07:08.985]                 if (inherits(cond, "error")) {
  [07:07:08.985]                   sessionInformation <- function() {
  [07:07:08.985]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:08.985]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:08.985]                       search = base::search(), system = base::Sys.info())
  [07:07:08.985]                   }
  [07:07:08.985]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.985]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:08.985]                     cond$call), session = sessionInformation(), 
  [07:07:08.985]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:08.985]                   signalCondition(cond)
  [07:07:08.985]                 }
  [07:07:08.985]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:08.985]                 ))) {
  [07:07:08.985]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:08.985]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:08.985]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:08.985]                   if (!signal) {
  [07:07:08.985]                     muffleCondition <- function (cond) 
  [07:07:08.985]                     {
  [07:07:08.985]                       inherits <- base::inherits
  [07:07:08.985]                       invokeRestart <- base::invokeRestart
  [07:07:08.985]                       muffled <- FALSE
  [07:07:08.985]                       if (inherits(cond, "message")) {
  [07:07:08.985]                         invokeRestart("muffleMessage")
  [07:07:08.985]                         muffled <- TRUE
  [07:07:08.985]                       }
  [07:07:08.985]                       else if (inherits(cond, "warning")) {
  [07:07:08.985]                         invokeRestart("muffleWarning")
  [07:07:08.985]                         muffled <- TRUE
  [07:07:08.985]                       }
  [07:07:08.985]                       else if (inherits(cond, "condition")) {
  [07:07:08.985]                         computeRestarts <- base::computeRestarts
  [07:07:08.985]                         grepl <- base::grepl
  [07:07:08.985]                         is.null <- base::is.null
  [07:07:08.985]                         restarts <- computeRestarts(cond)
  [07:07:08.985]                         for (restart in restarts) {
  [07:07:08.985]                           name <- restart$name
  [07:07:08.985]                           if (is.null(name)) 
  [07:07:08.985]                             next
  [07:07:08.985]                           if (!grepl("^muffle", name)) 
  [07:07:08.985]                             next
  [07:07:08.985]                           invokeRestart(restart)
  [07:07:08.985]                           muffled <- TRUE
  [07:07:08.985]                           break
  [07:07:08.985]                         }
  [07:07:08.985]                       }
  [07:07:08.985]                       invisible(muffled)
  [07:07:08.985]                     }
  [07:07:08.985]                     muffleCondition(cond)
  [07:07:08.985]                   }
  [07:07:08.985]                 }
  [07:07:08.985]             }
  [07:07:08.985]         }))
  [07:07:08.985]     }, error = function(ex) {
  [07:07:08.985]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:08.985]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:08.985]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:08.985]     }, finally = {
  [07:07:08.985]         {
  [07:07:08.985]             NULL
  [07:07:08.985]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:08.985]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:08.985]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:08.985]                 label = NULL, ...) 
  [07:07:08.985]             {
  [07:07:08.985]                 if (substitute) 
  [07:07:08.985]                   expr <- substitute(expr)
  [07:07:08.985]                 local <- as.logical(local)
  [07:07:08.985]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:08.985]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:08.985]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:08.985]                   label = label, ...)
  [07:07:08.985]                 if (!future$lazy) 
  [07:07:08.985]                   future <- run(future)
  [07:07:08.985]                 invisible(future)
  [07:07:08.985]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:08.985]         }
  [07:07:08.985]         base::options(...future.oldOptions)
  [07:07:08.985]     })
  [07:07:08.985]     Sys.time
  [07:07:08.985]     if (base::is.na(NA)) {
  [07:07:08.985]     }
  [07:07:08.985]     else {
  [07:07:08.985]         base::sink(type = "output", split = FALSE)
  [07:07:08.985]         if (NA) {
  [07:07:08.985]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:08.985]         }
  [07:07:08.985]         else {
  [07:07:08.985]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:08.985]         }
  [07:07:08.985]         base::close(...future.stdout)
  [07:07:08.985]         ...future.stdout <- NULL
  [07:07:08.985]     }
  [07:07:08.985]     ...future.result$conditions <- ...future.conditions
  [07:07:08.985]     ...future.result
  [07:07:08.985] }
  [07:07:08.996] plan(): Setting new future strategy stack:
  [07:07:09.000] List of future strategies:
  [07:07:09.000] 1. sequential:
  [07:07:09.000]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.000]    - tweaked: FALSE
  [07:07:09.000]    - call: NULL
  [07:07:09.005] plan(): nbrOfWorkers() = 1
  [07:07:09.010] plan(): Setting new future strategy stack:
  [07:07:09.014] List of future strategies:
  [07:07:09.014] 1. sequential:
  [07:07:09.014]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.014]    - tweaked: FALSE
  [07:07:09.014]    - call: NULL
  [07:07:09.019] plan(): nbrOfWorkers() = 1
  [07:07:09.022] SequentialFuture started (and completed)
  [07:07:09.029] Packages needed by the future expression (n = 0): <none>
  [07:07:09.032] Packages needed by future strategies (n = 0): <none>
  [07:07:09.041] {
  [07:07:09.041]     {
  [07:07:09.041]         ...future.startTime <- base::Sys.time()
  [07:07:09.041]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.041]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.041]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.041]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.041]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.041]         {
  [07:07:09.041]             {
  [07:07:09.041]                 base::local({
  [07:07:09.041]                   has_future <- base::requireNamespace("future", 
  [07:07:09.041]                     quietly = TRUE)
  [07:07:09.041]                   version <- if (has_future) 
  [07:07:09.041]                     utils::packageVersion("future")
  [07:07:09.041]                   else NULL
  [07:07:09.041]                   if (!has_future || version < "1.8.0") {
  [07:07:09.041]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.041]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.041]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.041]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.041]                         "release", "version")], collapse = " "), 
  [07:07:09.041]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.041]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.041]                       info)
  [07:07:09.041]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.041]                     if (!has_future) {
  [07:07:09.041]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.041]                         info)
  [07:07:09.041]                     }
  [07:07:09.041]                     else {
  [07:07:09.041]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.041]                         info, version)
  [07:07:09.041]                     }
  [07:07:09.041]                     base::stop(msg)
  [07:07:09.041]                   }
  [07:07:09.041]                 })
  [07:07:09.041]             }
  [07:07:09.041]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.041]         }
  [07:07:09.041]     }
  [07:07:09.041]     if (base::is.na(NA)) {
  [07:07:09.041]     }
  [07:07:09.041]     else {
  [07:07:09.041]         if (NA) {
  [07:07:09.041]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.041]                 open = "w")
  [07:07:09.041]         }
  [07:07:09.041]         else {
  [07:07:09.041]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.041]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.041]         }
  [07:07:09.041]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.041]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.041]             base::sink(type = "output", split = FALSE)
  [07:07:09.041]             base::close(...future.stdout)
  [07:07:09.041]         }, add = TRUE)
  [07:07:09.041]     }
  [07:07:09.041]     ...future.frame <- base::sys.nframe()
  [07:07:09.041]     ...future.conditions <- base::list()
  [07:07:09.041]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.041]     ...future.result <- base::tryCatch({
  [07:07:09.041]         base::withCallingHandlers({
  [07:07:09.041]             ...future.value <- base::withVisible(base::local({
  [07:07:09.041]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.041]             }))
  [07:07:09.041]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.041]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.041]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.041]                 version = "1.8")
  [07:07:09.041]         }, condition = base::local({
  [07:07:09.041]             c <- base::c
  [07:07:09.041]             inherits <- base::inherits
  [07:07:09.041]             invokeRestart <- base::invokeRestart
  [07:07:09.041]             length <- base::length
  [07:07:09.041]             list <- base::list
  [07:07:09.041]             seq.int <- base::seq.int
  [07:07:09.041]             signalCondition <- base::signalCondition
  [07:07:09.041]             sys.calls <- base::sys.calls
  [07:07:09.041]             Sys.time <- base::Sys.time
  [07:07:09.041]             `[[` <- base::`[[`
  [07:07:09.041]             `+` <- base::`+`
  [07:07:09.041]             `<<-` <- base::`<<-`
  [07:07:09.041]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.041]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.041]                   3L)]
  [07:07:09.041]             }
  [07:07:09.041]             function(cond) {
  [07:07:09.041]                 if (inherits(cond, "error")) {
  [07:07:09.041]                   sessionInformation <- function() {
  [07:07:09.041]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.041]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.041]                       search = base::search(), system = base::Sys.info())
  [07:07:09.041]                   }
  [07:07:09.041]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.041]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.041]                     cond$call), session = sessionInformation(), 
  [07:07:09.041]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.041]                   signalCondition(cond)
  [07:07:09.041]                 }
  [07:07:09.041]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.041]                 ))) {
  [07:07:09.041]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.041]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.041]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.041]                   if (!signal) {
  [07:07:09.041]                     muffleCondition <- function (cond) 
  [07:07:09.041]                     {
  [07:07:09.041]                       inherits <- base::inherits
  [07:07:09.041]                       invokeRestart <- base::invokeRestart
  [07:07:09.041]                       muffled <- FALSE
  [07:07:09.041]                       if (inherits(cond, "message")) {
  [07:07:09.041]                         invokeRestart("muffleMessage")
  [07:07:09.041]                         muffled <- TRUE
  [07:07:09.041]                       }
  [07:07:09.041]                       else if (inherits(cond, "warning")) {
  [07:07:09.041]                         invokeRestart("muffleWarning")
  [07:07:09.041]                         muffled <- TRUE
  [07:07:09.041]                       }
  [07:07:09.041]                       else if (inherits(cond, "condition")) {
  [07:07:09.041]                         computeRestarts <- base::computeRestarts
  [07:07:09.041]                         grepl <- base::grepl
  [07:07:09.041]                         is.null <- base::is.null
  [07:07:09.041]                         restarts <- computeRestarts(cond)
  [07:07:09.041]                         for (restart in restarts) {
  [07:07:09.041]                           name <- restart$name
  [07:07:09.041]                           if (is.null(name)) 
  [07:07:09.041]                             next
  [07:07:09.041]                           if (!grepl("^muffle", name)) 
  [07:07:09.041]                             next
  [07:07:09.041]                           invokeRestart(restart)
  [07:07:09.041]                           muffled <- TRUE
  [07:07:09.041]                           break
  [07:07:09.041]                         }
  [07:07:09.041]                       }
  [07:07:09.041]                       invisible(muffled)
  [07:07:09.041]                     }
  [07:07:09.041]                     muffleCondition(cond)
  [07:07:09.041]                   }
  [07:07:09.041]                 }
  [07:07:09.041]             }
  [07:07:09.041]         }))
  [07:07:09.041]     }, error = function(ex) {
  [07:07:09.041]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.041]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.041]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.041]     }, finally = {
  [07:07:09.041]         {
  [07:07:09.041]             NULL
  [07:07:09.041]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.041]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.041]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.041]                 label = NULL, ...) 
  [07:07:09.041]             {
  [07:07:09.041]                 if (substitute) 
  [07:07:09.041]                   expr <- substitute(expr)
  [07:07:09.041]                 local <- as.logical(local)
  [07:07:09.041]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.041]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.041]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.041]                   label = label, ...)
  [07:07:09.041]                 if (!future$lazy) 
  [07:07:09.041]                   future <- run(future)
  [07:07:09.041]                 invisible(future)
  [07:07:09.041]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.041]         }
  [07:07:09.041]         base::options(...future.oldOptions)
  [07:07:09.041]     })
  [07:07:09.041]     Sys.time
  [07:07:09.041]     if (base::is.na(NA)) {
  [07:07:09.041]     }
  [07:07:09.041]     else {
  [07:07:09.041]         base::sink(type = "output", split = FALSE)
  [07:07:09.041]         if (NA) {
  [07:07:09.041]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.041]         }
  [07:07:09.041]         else {
  [07:07:09.041]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.041]         }
  [07:07:09.041]         base::close(...future.stdout)
  [07:07:09.041]         ...future.stdout <- NULL
  [07:07:09.041]     }
  [07:07:09.041]     ...future.result$conditions <- ...future.conditions
  [07:07:09.041]     ...future.result
  [07:07:09.041] }
  [07:07:09.052] plan(): Setting new future strategy stack:
  [07:07:09.056] List of future strategies:
  [07:07:09.056] 1. sequential:
  [07:07:09.056]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.056]    - tweaked: FALSE
  [07:07:09.056]    - call: NULL
  [07:07:09.061] plan(): nbrOfWorkers() = 1
  [07:07:09.066] plan(): Setting new future strategy stack:
  [07:07:09.070] List of future strategies:
  [07:07:09.070] 1. sequential:
  [07:07:09.070]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.070]    - tweaked: FALSE
  [07:07:09.070]    - call: NULL
  [07:07:09.075] plan(): nbrOfWorkers() = 1
  [07:07:09.079] SequentialFuture started (and completed)
  [07:07:09.083] plan(): Setting new future strategy stack:
  [07:07:09.086] List of future strategies:
  [07:07:09.086] 1. sequential:
  [07:07:09.086]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.086]    - tweaked: FALSE
  [07:07:09.086]    - call: NULL
  [07:07:09.091] plan(): nbrOfWorkers() = 1
  [07:07:09.094] SequentialFuture started (and completed)
  [07:07:09.100] Packages needed by the future expression (n = 0): <none>
  [07:07:09.104] Packages needed by future strategies (n = 0): <none>
  [07:07:09.118] {
  [07:07:09.118]     {
  [07:07:09.118]         ...future.startTime <- base::Sys.time()
  [07:07:09.118]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.118]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.118]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.118]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.118]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.118]         {
  [07:07:09.118]             {
  [07:07:09.118]                 base::local({
  [07:07:09.118]                   has_future <- base::requireNamespace("future", 
  [07:07:09.118]                     quietly = TRUE)
  [07:07:09.118]                   version <- if (has_future) 
  [07:07:09.118]                     utils::packageVersion("future")
  [07:07:09.118]                   else NULL
  [07:07:09.118]                   if (!has_future || version < "1.8.0") {
  [07:07:09.118]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.118]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.118]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.118]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.118]                         "release", "version")], collapse = " "), 
  [07:07:09.118]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.118]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.118]                       info)
  [07:07:09.118]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.118]                     if (!has_future) {
  [07:07:09.118]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.118]                         info)
  [07:07:09.118]                     }
  [07:07:09.118]                     else {
  [07:07:09.118]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.118]                         info, version)
  [07:07:09.118]                     }
  [07:07:09.118]                     base::stop(msg)
  [07:07:09.118]                   }
  [07:07:09.118]                 })
  [07:07:09.118]             }
  [07:07:09.118]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.118]         }
  [07:07:09.118]     }
  [07:07:09.118]     if (base::is.na(NA)) {
  [07:07:09.118]     }
  [07:07:09.118]     else {
  [07:07:09.118]         if (NA) {
  [07:07:09.118]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.118]                 open = "w")
  [07:07:09.118]         }
  [07:07:09.118]         else {
  [07:07:09.118]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.118]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.118]         }
  [07:07:09.118]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.118]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.118]             base::sink(type = "output", split = FALSE)
  [07:07:09.118]             base::close(...future.stdout)
  [07:07:09.118]         }, add = TRUE)
  [07:07:09.118]     }
  [07:07:09.118]     ...future.frame <- base::sys.nframe()
  [07:07:09.118]     ...future.conditions <- base::list()
  [07:07:09.118]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.118]     ...future.result <- base::tryCatch({
  [07:07:09.118]         base::withCallingHandlers({
  [07:07:09.118]             ...future.value <- base::withVisible(base::local({
  [07:07:09.118]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.118]             }))
  [07:07:09.118]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.118]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.118]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.118]                 version = "1.8")
  [07:07:09.118]         }, condition = base::local({
  [07:07:09.118]             c <- base::c
  [07:07:09.118]             inherits <- base::inherits
  [07:07:09.118]             invokeRestart <- base::invokeRestart
  [07:07:09.118]             length <- base::length
  [07:07:09.118]             list <- base::list
  [07:07:09.118]             seq.int <- base::seq.int
  [07:07:09.118]             signalCondition <- base::signalCondition
  [07:07:09.118]             sys.calls <- base::sys.calls
  [07:07:09.118]             Sys.time <- base::Sys.time
  [07:07:09.118]             `[[` <- base::`[[`
  [07:07:09.118]             `+` <- base::`+`
  [07:07:09.118]             `<<-` <- base::`<<-`
  [07:07:09.118]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.118]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.118]                   3L)]
  [07:07:09.118]             }
  [07:07:09.118]             function(cond) {
  [07:07:09.118]                 if (inherits(cond, "error")) {
  [07:07:09.118]                   sessionInformation <- function() {
  [07:07:09.118]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.118]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.118]                       search = base::search(), system = base::Sys.info())
  [07:07:09.118]                   }
  [07:07:09.118]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.118]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.118]                     cond$call), session = sessionInformation(), 
  [07:07:09.118]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.118]                   signalCondition(cond)
  [07:07:09.118]                 }
  [07:07:09.118]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.118]                 ))) {
  [07:07:09.118]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.118]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.118]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.118]                   if (!signal) {
  [07:07:09.118]                     muffleCondition <- function (cond) 
  [07:07:09.118]                     {
  [07:07:09.118]                       inherits <- base::inherits
  [07:07:09.118]                       invokeRestart <- base::invokeRestart
  [07:07:09.118]                       muffled <- FALSE
  [07:07:09.118]                       if (inherits(cond, "message")) {
  [07:07:09.118]                         invokeRestart("muffleMessage")
  [07:07:09.118]                         muffled <- TRUE
  [07:07:09.118]                       }
  [07:07:09.118]                       else if (inherits(cond, "warning")) {
  [07:07:09.118]                         invokeRestart("muffleWarning")
  [07:07:09.118]                         muffled <- TRUE
  [07:07:09.118]                       }
  [07:07:09.118]                       else if (inherits(cond, "condition")) {
  [07:07:09.118]                         computeRestarts <- base::computeRestarts
  [07:07:09.118]                         grepl <- base::grepl
  [07:07:09.118]                         is.null <- base::is.null
  [07:07:09.118]                         restarts <- computeRestarts(cond)
  [07:07:09.118]                         for (restart in restarts) {
  [07:07:09.118]                           name <- restart$name
  [07:07:09.118]                           if (is.null(name)) 
  [07:07:09.118]                             next
  [07:07:09.118]                           if (!grepl("^muffle", name)) 
  [07:07:09.118]                             next
  [07:07:09.118]                           invokeRestart(restart)
  [07:07:09.118]                           muffled <- TRUE
  [07:07:09.118]                           break
  [07:07:09.118]                         }
  [07:07:09.118]                       }
  [07:07:09.118]                       invisible(muffled)
  [07:07:09.118]                     }
  [07:07:09.118]                     muffleCondition(cond)
  [07:07:09.118]                   }
  [07:07:09.118]                 }
  [07:07:09.118]             }
  [07:07:09.118]         }))
  [07:07:09.118]     }, error = function(ex) {
  [07:07:09.118]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.118]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.118]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.118]     }, finally = {
  [07:07:09.118]         {
  [07:07:09.118]             NULL
  [07:07:09.118]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.118]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.118]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.118]                 label = NULL, ...) 
  [07:07:09.118]             {
  [07:07:09.118]                 if (substitute) 
  [07:07:09.118]                   expr <- substitute(expr)
  [07:07:09.118]                 local <- as.logical(local)
  [07:07:09.118]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.118]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.118]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.118]                   label = label, ...)
  [07:07:09.118]                 if (!future$lazy) 
  [07:07:09.118]                   future <- run(future)
  [07:07:09.118]                 invisible(future)
  [07:07:09.118]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.118]         }
  [07:07:09.118]         base::options(...future.oldOptions)
  [07:07:09.118]     })
  [07:07:09.118]     Sys.time
  [07:07:09.118]     if (base::is.na(NA)) {
  [07:07:09.118]     }
  [07:07:09.118]     else {
  [07:07:09.118]         base::sink(type = "output", split = FALSE)
  [07:07:09.118]         if (NA) {
  [07:07:09.118]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.118]         }
  [07:07:09.118]         else {
  [07:07:09.118]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.118]         }
  [07:07:09.118]         base::close(...future.stdout)
  [07:07:09.118]         ...future.stdout <- NULL
  [07:07:09.118]     }
  [07:07:09.118]     ...future.result$conditions <- ...future.conditions
  [07:07:09.118]     ...future.result
  [07:07:09.118] }
  [07:07:09.128] plan(): Setting new future strategy stack:
  [07:07:09.132] List of future strategies:
  [07:07:09.132] 1. sequential:
  [07:07:09.132]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.132]    - tweaked: FALSE
  [07:07:09.132]    - call: NULL
  [07:07:09.137] plan(): nbrOfWorkers() = 1
  [07:07:09.141] plan(): Setting new future strategy stack:
  [07:07:09.145] List of future strategies:
  [07:07:09.145] 1. sequential:
  [07:07:09.145]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.145]    - tweaked: FALSE
  [07:07:09.145]    - call: NULL
  [07:07:09.150] plan(): nbrOfWorkers() = 1
  [07:07:09.154] SequentialFuture started (and completed)
  [07:07:09.158] plan(): Setting new future strategy stack:
  [07:07:09.162] List of future strategies:
  [07:07:09.162] 1. sequential:
  [07:07:09.162]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.162]    - tweaked: FALSE
  [07:07:09.162]    - call: NULL
  [07:07:09.167] plan(): nbrOfWorkers() = 1
  [07:07:09.170] SequentialFuture started (and completed)
  [07:07:09.177] Packages needed by the future expression (n = 0): <none>
  [07:07:09.180] Packages needed by future strategies (n = 0): <none>
  [07:07:09.190] {
  [07:07:09.190]     {
  [07:07:09.190]         ...future.startTime <- base::Sys.time()
  [07:07:09.190]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.190]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.190]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.190]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.190]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.190]         {
  [07:07:09.190]             {
  [07:07:09.190]                 base::local({
  [07:07:09.190]                   has_future <- base::requireNamespace("future", 
  [07:07:09.190]                     quietly = TRUE)
  [07:07:09.190]                   version <- if (has_future) 
  [07:07:09.190]                     utils::packageVersion("future")
  [07:07:09.190]                   else NULL
  [07:07:09.190]                   if (!has_future || version < "1.8.0") {
  [07:07:09.190]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.190]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.190]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.190]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.190]                         "release", "version")], collapse = " "), 
  [07:07:09.190]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.190]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.190]                       info)
  [07:07:09.190]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.190]                     if (!has_future) {
  [07:07:09.190]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.190]                         info)
  [07:07:09.190]                     }
  [07:07:09.190]                     else {
  [07:07:09.190]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.190]                         info, version)
  [07:07:09.190]                     }
  [07:07:09.190]                     base::stop(msg)
  [07:07:09.190]                   }
  [07:07:09.190]                 })
  [07:07:09.190]             }
  [07:07:09.190]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.190]         }
  [07:07:09.190]     }
  [07:07:09.190]     if (base::is.na(NA)) {
  [07:07:09.190]     }
  [07:07:09.190]     else {
  [07:07:09.190]         if (NA) {
  [07:07:09.190]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.190]                 open = "w")
  [07:07:09.190]         }
  [07:07:09.190]         else {
  [07:07:09.190]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.190]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.190]         }
  [07:07:09.190]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.190]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.190]             base::sink(type = "output", split = FALSE)
  [07:07:09.190]             base::close(...future.stdout)
  [07:07:09.190]         }, add = TRUE)
  [07:07:09.190]     }
  [07:07:09.190]     ...future.frame <- base::sys.nframe()
  [07:07:09.190]     ...future.conditions <- base::list()
  [07:07:09.190]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.190]     ...future.result <- base::tryCatch({
  [07:07:09.190]         base::withCallingHandlers({
  [07:07:09.190]             ...future.value <- base::withVisible(base::local({
  [07:07:09.190]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.190]             }))
  [07:07:09.190]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.190]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.190]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.190]                 version = "1.8")
  [07:07:09.190]         }, condition = base::local({
  [07:07:09.190]             c <- base::c
  [07:07:09.190]             inherits <- base::inherits
  [07:07:09.190]             invokeRestart <- base::invokeRestart
  [07:07:09.190]             length <- base::length
  [07:07:09.190]             list <- base::list
  [07:07:09.190]             seq.int <- base::seq.int
  [07:07:09.190]             signalCondition <- base::signalCondition
  [07:07:09.190]             sys.calls <- base::sys.calls
  [07:07:09.190]             Sys.time <- base::Sys.time
  [07:07:09.190]             `[[` <- base::`[[`
  [07:07:09.190]             `+` <- base::`+`
  [07:07:09.190]             `<<-` <- base::`<<-`
  [07:07:09.190]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.190]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.190]                   3L)]
  [07:07:09.190]             }
  [07:07:09.190]             function(cond) {
  [07:07:09.190]                 if (inherits(cond, "error")) {
  [07:07:09.190]                   sessionInformation <- function() {
  [07:07:09.190]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.190]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.190]                       search = base::search(), system = base::Sys.info())
  [07:07:09.190]                   }
  [07:07:09.190]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.190]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.190]                     cond$call), session = sessionInformation(), 
  [07:07:09.190]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.190]                   signalCondition(cond)
  [07:07:09.190]                 }
  [07:07:09.190]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.190]                 ))) {
  [07:07:09.190]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.190]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.190]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.190]                   if (!signal) {
  [07:07:09.190]                     muffleCondition <- function (cond) 
  [07:07:09.190]                     {
  [07:07:09.190]                       inherits <- base::inherits
  [07:07:09.190]                       invokeRestart <- base::invokeRestart
  [07:07:09.190]                       muffled <- FALSE
  [07:07:09.190]                       if (inherits(cond, "message")) {
  [07:07:09.190]                         invokeRestart("muffleMessage")
  [07:07:09.190]                         muffled <- TRUE
  [07:07:09.190]                       }
  [07:07:09.190]                       else if (inherits(cond, "warning")) {
  [07:07:09.190]                         invokeRestart("muffleWarning")
  [07:07:09.190]                         muffled <- TRUE
  [07:07:09.190]                       }
  [07:07:09.190]                       else if (inherits(cond, "condition")) {
  [07:07:09.190]                         computeRestarts <- base::computeRestarts
  [07:07:09.190]                         grepl <- base::grepl
  [07:07:09.190]                         is.null <- base::is.null
  [07:07:09.190]                         restarts <- computeRestarts(cond)
  [07:07:09.190]                         for (restart in restarts) {
  [07:07:09.190]                           name <- restart$name
  [07:07:09.190]                           if (is.null(name)) 
  [07:07:09.190]                             next
  [07:07:09.190]                           if (!grepl("^muffle", name)) 
  [07:07:09.190]                             next
  [07:07:09.190]                           invokeRestart(restart)
  [07:07:09.190]                           muffled <- TRUE
  [07:07:09.190]                           break
  [07:07:09.190]                         }
  [07:07:09.190]                       }
  [07:07:09.190]                       invisible(muffled)
  [07:07:09.190]                     }
  [07:07:09.190]                     muffleCondition(cond)
  [07:07:09.190]                   }
  [07:07:09.190]                 }
  [07:07:09.190]             }
  [07:07:09.190]         }))
  [07:07:09.190]     }, error = function(ex) {
  [07:07:09.190]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.190]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.190]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.190]     }, finally = {
  [07:07:09.190]         {
  [07:07:09.190]             NULL
  [07:07:09.190]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.190]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.190]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.190]                 label = NULL, ...) 
  [07:07:09.190]             {
  [07:07:09.190]                 if (substitute) 
  [07:07:09.190]                   expr <- substitute(expr)
  [07:07:09.190]                 local <- as.logical(local)
  [07:07:09.190]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.190]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.190]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.190]                   label = label, ...)
  [07:07:09.190]                 if (!future$lazy) 
  [07:07:09.190]                   future <- run(future)
  [07:07:09.190]                 invisible(future)
  [07:07:09.190]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.190]         }
  [07:07:09.190]         base::options(...future.oldOptions)
  [07:07:09.190]     })
  [07:07:09.190]     Sys.time
  [07:07:09.190]     if (base::is.na(NA)) {
  [07:07:09.190]     }
  [07:07:09.190]     else {
  [07:07:09.190]         base::sink(type = "output", split = FALSE)
  [07:07:09.190]         if (NA) {
  [07:07:09.190]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.190]         }
  [07:07:09.190]         else {
  [07:07:09.190]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.190]         }
  [07:07:09.190]         base::close(...future.stdout)
  [07:07:09.190]         ...future.stdout <- NULL
  [07:07:09.190]     }
  [07:07:09.190]     ...future.result$conditions <- ...future.conditions
  [07:07:09.190]     ...future.result
  [07:07:09.190] }
  [07:07:09.201] plan(): Setting new future strategy stack:
  [07:07:09.204] List of future strategies:
  [07:07:09.204] 1. sequential:
  [07:07:09.204]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.204]    - tweaked: FALSE
  [07:07:09.204]    - call: NULL
  [07:07:09.209] plan(): nbrOfWorkers() = 1
  [07:07:09.214] plan(): Setting new future strategy stack:
  [07:07:09.217] List of future strategies:
  [07:07:09.217] 1. sequential:
  [07:07:09.217]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.217]    - tweaked: FALSE
  [07:07:09.217]    - call: NULL
  [07:07:09.222] plan(): nbrOfWorkers() = 1
  [07:07:09.225] SequentialFuture started (and completed)
  [07:07:09.230] plan(): Setting new future strategy stack:
  [07:07:09.233] List of future strategies:
  [07:07:09.233] 1. sequential:
  [07:07:09.233]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.233]    - tweaked: FALSE
  [07:07:09.233]    - call: NULL
  [07:07:09.237] plan(): nbrOfWorkers() = 1
  [07:07:09.241] SequentialFuture started (and completed)
  [07:07:09.246] Packages needed by the future expression (n = 0): <none>
  [07:07:09.250] Packages needed by future strategies (n = 0): <none>
  [07:07:09.260] {
  [07:07:09.260]     {
  [07:07:09.260]         ...future.startTime <- base::Sys.time()
  [07:07:09.260]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.260]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.260]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.260]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.260]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.260]         {
  [07:07:09.260]             {
  [07:07:09.260]                 base::local({
  [07:07:09.260]                   has_future <- base::requireNamespace("future", 
  [07:07:09.260]                     quietly = TRUE)
  [07:07:09.260]                   version <- if (has_future) 
  [07:07:09.260]                     utils::packageVersion("future")
  [07:07:09.260]                   else NULL
  [07:07:09.260]                   if (!has_future || version < "1.8.0") {
  [07:07:09.260]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.260]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.260]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.260]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.260]                         "release", "version")], collapse = " "), 
  [07:07:09.260]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.260]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.260]                       info)
  [07:07:09.260]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.260]                     if (!has_future) {
  [07:07:09.260]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.260]                         info)
  [07:07:09.260]                     }
  [07:07:09.260]                     else {
  [07:07:09.260]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.260]                         info, version)
  [07:07:09.260]                     }
  [07:07:09.260]                     base::stop(msg)
  [07:07:09.260]                   }
  [07:07:09.260]                 })
  [07:07:09.260]             }
  [07:07:09.260]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.260]         }
  [07:07:09.260]     }
  [07:07:09.260]     if (base::is.na(NA)) {
  [07:07:09.260]     }
  [07:07:09.260]     else {
  [07:07:09.260]         if (NA) {
  [07:07:09.260]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.260]                 open = "w")
  [07:07:09.260]         }
  [07:07:09.260]         else {
  [07:07:09.260]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.260]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.260]         }
  [07:07:09.260]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.260]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.260]             base::sink(type = "output", split = FALSE)
  [07:07:09.260]             base::close(...future.stdout)
  [07:07:09.260]         }, add = TRUE)
  [07:07:09.260]     }
  [07:07:09.260]     ...future.frame <- base::sys.nframe()
  [07:07:09.260]     ...future.conditions <- base::list()
  [07:07:09.260]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.260]     ...future.result <- base::tryCatch({
  [07:07:09.260]         base::withCallingHandlers({
  [07:07:09.260]             ...future.value <- base::withVisible(base::local({
  [07:07:09.260]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.260]             }))
  [07:07:09.260]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.260]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.260]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.260]                 version = "1.8")
  [07:07:09.260]         }, condition = base::local({
  [07:07:09.260]             c <- base::c
  [07:07:09.260]             inherits <- base::inherits
  [07:07:09.260]             invokeRestart <- base::invokeRestart
  [07:07:09.260]             length <- base::length
  [07:07:09.260]             list <- base::list
  [07:07:09.260]             seq.int <- base::seq.int
  [07:07:09.260]             signalCondition <- base::signalCondition
  [07:07:09.260]             sys.calls <- base::sys.calls
  [07:07:09.260]             Sys.time <- base::Sys.time
  [07:07:09.260]             `[[` <- base::`[[`
  [07:07:09.260]             `+` <- base::`+`
  [07:07:09.260]             `<<-` <- base::`<<-`
  [07:07:09.260]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.260]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.260]                   3L)]
  [07:07:09.260]             }
  [07:07:09.260]             function(cond) {
  [07:07:09.260]                 if (inherits(cond, "error")) {
  [07:07:09.260]                   sessionInformation <- function() {
  [07:07:09.260]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.260]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.260]                       search = base::search(), system = base::Sys.info())
  [07:07:09.260]                   }
  [07:07:09.260]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.260]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.260]                     cond$call), session = sessionInformation(), 
  [07:07:09.260]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.260]                   signalCondition(cond)
  [07:07:09.260]                 }
  [07:07:09.260]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.260]                 ))) {
  [07:07:09.260]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.260]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.260]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.260]                   if (!signal) {
  [07:07:09.260]                     muffleCondition <- function (cond) 
  [07:07:09.260]                     {
  [07:07:09.260]                       inherits <- base::inherits
  [07:07:09.260]                       invokeRestart <- base::invokeRestart
  [07:07:09.260]                       muffled <- FALSE
  [07:07:09.260]                       if (inherits(cond, "message")) {
  [07:07:09.260]                         invokeRestart("muffleMessage")
  [07:07:09.260]                         muffled <- TRUE
  [07:07:09.260]                       }
  [07:07:09.260]                       else if (inherits(cond, "warning")) {
  [07:07:09.260]                         invokeRestart("muffleWarning")
  [07:07:09.260]                         muffled <- TRUE
  [07:07:09.260]                       }
  [07:07:09.260]                       else if (inherits(cond, "condition")) {
  [07:07:09.260]                         computeRestarts <- base::computeRestarts
  [07:07:09.260]                         grepl <- base::grepl
  [07:07:09.260]                         is.null <- base::is.null
  [07:07:09.260]                         restarts <- computeRestarts(cond)
  [07:07:09.260]                         for (restart in restarts) {
  [07:07:09.260]                           name <- restart$name
  [07:07:09.260]                           if (is.null(name)) 
  [07:07:09.260]                             next
  [07:07:09.260]                           if (!grepl("^muffle", name)) 
  [07:07:09.260]                             next
  [07:07:09.260]                           invokeRestart(restart)
  [07:07:09.260]                           muffled <- TRUE
  [07:07:09.260]                           break
  [07:07:09.260]                         }
  [07:07:09.260]                       }
  [07:07:09.260]                       invisible(muffled)
  [07:07:09.260]                     }
  [07:07:09.260]                     muffleCondition(cond)
  [07:07:09.260]                   }
  [07:07:09.260]                 }
  [07:07:09.260]             }
  [07:07:09.260]         }))
  [07:07:09.260]     }, error = function(ex) {
  [07:07:09.260]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.260]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.260]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.260]     }, finally = {
  [07:07:09.260]         {
  [07:07:09.260]             NULL
  [07:07:09.260]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.260]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.260]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.260]                 label = NULL, ...) 
  [07:07:09.260]             {
  [07:07:09.260]                 if (substitute) 
  [07:07:09.260]                   expr <- substitute(expr)
  [07:07:09.260]                 local <- as.logical(local)
  [07:07:09.260]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.260]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.260]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.260]                   label = label, ...)
  [07:07:09.260]                 if (!future$lazy) 
  [07:07:09.260]                   future <- run(future)
  [07:07:09.260]                 invisible(future)
  [07:07:09.260]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.260]         }
  [07:07:09.260]         base::options(...future.oldOptions)
  [07:07:09.260]     })
  [07:07:09.260]     Sys.time
  [07:07:09.260]     if (base::is.na(NA)) {
  [07:07:09.260]     }
  [07:07:09.260]     else {
  [07:07:09.260]         base::sink(type = "output", split = FALSE)
  [07:07:09.260]         if (NA) {
  [07:07:09.260]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.260]         }
  [07:07:09.260]         else {
  [07:07:09.260]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.260]         }
  [07:07:09.260]         base::close(...future.stdout)
  [07:07:09.260]         ...future.stdout <- NULL
  [07:07:09.260]     }
  [07:07:09.260]     ...future.result$conditions <- ...future.conditions
  [07:07:09.260]     ...future.result
  [07:07:09.260] }
  [07:07:09.270] plan(): Setting new future strategy stack:
  [07:07:09.273] List of future strategies:
  [07:07:09.273] 1. sequential:
  [07:07:09.273]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.273]    - tweaked: FALSE
  [07:07:09.273]    - call: NULL
  [07:07:09.278] plan(): nbrOfWorkers() = 1
  [07:07:09.282] plan(): Setting new future strategy stack:
  [07:07:09.285] List of future strategies:
  [07:07:09.285] 1. sequential:
  [07:07:09.285]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.285]    - tweaked: FALSE
  [07:07:09.285]    - call: NULL
  [07:07:09.289] plan(): nbrOfWorkers() = 1
  [07:07:09.292] SequentialFuture started (and completed)
  [07:07:09.296] plan(): Setting new future strategy stack:
  [07:07:09.300] List of future strategies:
  [07:07:09.300] 1. sequential:
  [07:07:09.300]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.300]    - tweaked: FALSE
  [07:07:09.300]    - call: NULL
  [07:07:09.304] plan(): nbrOfWorkers() = 1
  [07:07:09.311] SequentialFuture started (and completed)
  [07:07:09.318] Packages needed by the future expression (n = 0): <none>
  [07:07:09.321] Packages needed by future strategies (n = 0): <none>
  [07:07:09.330] {
  [07:07:09.330]     {
  [07:07:09.330]         ...future.startTime <- base::Sys.time()
  [07:07:09.330]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.330]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.330]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.330]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.330]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.330]         {
  [07:07:09.330]             {
  [07:07:09.330]                 base::local({
  [07:07:09.330]                   has_future <- base::requireNamespace("future", 
  [07:07:09.330]                     quietly = TRUE)
  [07:07:09.330]                   version <- if (has_future) 
  [07:07:09.330]                     utils::packageVersion("future")
  [07:07:09.330]                   else NULL
  [07:07:09.330]                   if (!has_future || version < "1.8.0") {
  [07:07:09.330]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.330]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.330]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.330]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.330]                         "release", "version")], collapse = " "), 
  [07:07:09.330]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.330]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.330]                       info)
  [07:07:09.330]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.330]                     if (!has_future) {
  [07:07:09.330]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.330]                         info)
  [07:07:09.330]                     }
  [07:07:09.330]                     else {
  [07:07:09.330]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.330]                         info, version)
  [07:07:09.330]                     }
  [07:07:09.330]                     base::stop(msg)
  [07:07:09.330]                   }
  [07:07:09.330]                 })
  [07:07:09.330]             }
  [07:07:09.330]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.330]         }
  [07:07:09.330]     }
  [07:07:09.330]     if (base::is.na(NA)) {
  [07:07:09.330]     }
  [07:07:09.330]     else {
  [07:07:09.330]         if (NA) {
  [07:07:09.330]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.330]                 open = "w")
  [07:07:09.330]         }
  [07:07:09.330]         else {
  [07:07:09.330]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.330]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.330]         }
  [07:07:09.330]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.330]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.330]             base::sink(type = "output", split = FALSE)
  [07:07:09.330]             base::close(...future.stdout)
  [07:07:09.330]         }, add = TRUE)
  [07:07:09.330]     }
  [07:07:09.330]     ...future.frame <- base::sys.nframe()
  [07:07:09.330]     ...future.conditions <- base::list()
  [07:07:09.330]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.330]     ...future.result <- base::tryCatch({
  [07:07:09.330]         base::withCallingHandlers({
  [07:07:09.330]             ...future.value <- base::withVisible(base::local({
  [07:07:09.330]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.330]             }))
  [07:07:09.330]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.330]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.330]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.330]                 version = "1.8")
  [07:07:09.330]         }, condition = base::local({
  [07:07:09.330]             c <- base::c
  [07:07:09.330]             inherits <- base::inherits
  [07:07:09.330]             invokeRestart <- base::invokeRestart
  [07:07:09.330]             length <- base::length
  [07:07:09.330]             list <- base::list
  [07:07:09.330]             seq.int <- base::seq.int
  [07:07:09.330]             signalCondition <- base::signalCondition
  [07:07:09.330]             sys.calls <- base::sys.calls
  [07:07:09.330]             Sys.time <- base::Sys.time
  [07:07:09.330]             `[[` <- base::`[[`
  [07:07:09.330]             `+` <- base::`+`
  [07:07:09.330]             `<<-` <- base::`<<-`
  [07:07:09.330]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.330]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.330]                   3L)]
  [07:07:09.330]             }
  [07:07:09.330]             function(cond) {
  [07:07:09.330]                 if (inherits(cond, "error")) {
  [07:07:09.330]                   sessionInformation <- function() {
  [07:07:09.330]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.330]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.330]                       search = base::search(), system = base::Sys.info())
  [07:07:09.330]                   }
  [07:07:09.330]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.330]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.330]                     cond$call), session = sessionInformation(), 
  [07:07:09.330]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.330]                   signalCondition(cond)
  [07:07:09.330]                 }
  [07:07:09.330]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.330]                 ))) {
  [07:07:09.330]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.330]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.330]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.330]                   if (!signal) {
  [07:07:09.330]                     muffleCondition <- function (cond) 
  [07:07:09.330]                     {
  [07:07:09.330]                       inherits <- base::inherits
  [07:07:09.330]                       invokeRestart <- base::invokeRestart
  [07:07:09.330]                       muffled <- FALSE
  [07:07:09.330]                       if (inherits(cond, "message")) {
  [07:07:09.330]                         invokeRestart("muffleMessage")
  [07:07:09.330]                         muffled <- TRUE
  [07:07:09.330]                       }
  [07:07:09.330]                       else if (inherits(cond, "warning")) {
  [07:07:09.330]                         invokeRestart("muffleWarning")
  [07:07:09.330]                         muffled <- TRUE
  [07:07:09.330]                       }
  [07:07:09.330]                       else if (inherits(cond, "condition")) {
  [07:07:09.330]                         computeRestarts <- base::computeRestarts
  [07:07:09.330]                         grepl <- base::grepl
  [07:07:09.330]                         is.null <- base::is.null
  [07:07:09.330]                         restarts <- computeRestarts(cond)
  [07:07:09.330]                         for (restart in restarts) {
  [07:07:09.330]                           name <- restart$name
  [07:07:09.330]                           if (is.null(name)) 
  [07:07:09.330]                             next
  [07:07:09.330]                           if (!grepl("^muffle", name)) 
  [07:07:09.330]                             next
  [07:07:09.330]                           invokeRestart(restart)
  [07:07:09.330]                           muffled <- TRUE
  [07:07:09.330]                           break
  [07:07:09.330]                         }
  [07:07:09.330]                       }
  [07:07:09.330]                       invisible(muffled)
  [07:07:09.330]                     }
  [07:07:09.330]                     muffleCondition(cond)
  [07:07:09.330]                   }
  [07:07:09.330]                 }
  [07:07:09.330]             }
  [07:07:09.330]         }))
  [07:07:09.330]     }, error = function(ex) {
  [07:07:09.330]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.330]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.330]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.330]     }, finally = {
  [07:07:09.330]         {
  [07:07:09.330]             NULL
  [07:07:09.330]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.330]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.330]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.330]                 label = NULL, ...) 
  [07:07:09.330]             {
  [07:07:09.330]                 if (substitute) 
  [07:07:09.330]                   expr <- substitute(expr)
  [07:07:09.330]                 local <- as.logical(local)
  [07:07:09.330]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.330]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.330]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.330]                   label = label, ...)
  [07:07:09.330]                 if (!future$lazy) 
  [07:07:09.330]                   future <- run(future)
  [07:07:09.330]                 invisible(future)
  [07:07:09.330]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.330]         }
  [07:07:09.330]         base::options(...future.oldOptions)
  [07:07:09.330]     })
  [07:07:09.330]     Sys.time
  [07:07:09.330]     if (base::is.na(NA)) {
  [07:07:09.330]     }
  [07:07:09.330]     else {
  [07:07:09.330]         base::sink(type = "output", split = FALSE)
  [07:07:09.330]         if (NA) {
  [07:07:09.330]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.330]         }
  [07:07:09.330]         else {
  [07:07:09.330]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.330]         }
  [07:07:09.330]         base::close(...future.stdout)
  [07:07:09.330]         ...future.stdout <- NULL
  [07:07:09.330]     }
  [07:07:09.330]     ...future.result$conditions <- ...future.conditions
  [07:07:09.330]     ...future.result
  [07:07:09.330] }
  [07:07:09.340] plan(): Setting new future strategy stack:
  [07:07:09.344] List of future strategies:
  [07:07:09.344] 1. sequential:
  [07:07:09.344]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.344]    - tweaked: FALSE
  [07:07:09.344]    - call: NULL
  [07:07:09.348] plan(): nbrOfWorkers() = 1
  [07:07:09.352] plan(): Setting new future strategy stack:
  [07:07:09.355] List of future strategies:
  [07:07:09.355] 1. sequential:
  [07:07:09.355]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.355]    - tweaked: FALSE
  [07:07:09.355]    - call: NULL
  [07:07:09.359] plan(): nbrOfWorkers() = 1
  [07:07:09.362] SequentialFuture started (and completed)
  [07:07:09.366] plan(): Setting new future strategy stack:
  [07:07:09.369] List of future strategies:
  [07:07:09.369] 1. sequential:
  [07:07:09.369]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.369]    - tweaked: FALSE
  [07:07:09.369]    - call: NULL
  [07:07:09.373] plan(): nbrOfWorkers() = 1
  [07:07:09.376] SequentialFuture started (and completed)
  [07:07:09.381] Packages needed by the future expression (n = 0): <none>
  [07:07:09.384] Packages needed by future strategies (n = 0): <none>
  [07:07:09.393] {
  [07:07:09.393]     {
  [07:07:09.393]         ...future.startTime <- base::Sys.time()
  [07:07:09.393]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.393]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.393]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.393]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.393]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.393]         {
  [07:07:09.393]             {
  [07:07:09.393]                 base::local({
  [07:07:09.393]                   has_future <- base::requireNamespace("future", 
  [07:07:09.393]                     quietly = TRUE)
  [07:07:09.393]                   version <- if (has_future) 
  [07:07:09.393]                     utils::packageVersion("future")
  [07:07:09.393]                   else NULL
  [07:07:09.393]                   if (!has_future || version < "1.8.0") {
  [07:07:09.393]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.393]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.393]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.393]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.393]                         "release", "version")], collapse = " "), 
  [07:07:09.393]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.393]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.393]                       info)
  [07:07:09.393]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.393]                     if (!has_future) {
  [07:07:09.393]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.393]                         info)
  [07:07:09.393]                     }
  [07:07:09.393]                     else {
  [07:07:09.393]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.393]                         info, version)
  [07:07:09.393]                     }
  [07:07:09.393]                     base::stop(msg)
  [07:07:09.393]                   }
  [07:07:09.393]                 })
  [07:07:09.393]             }
  [07:07:09.393]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.393]         }
  [07:07:09.393]     }
  [07:07:09.393]     if (base::is.na(NA)) {
  [07:07:09.393]     }
  [07:07:09.393]     else {
  [07:07:09.393]         if (NA) {
  [07:07:09.393]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.393]                 open = "w")
  [07:07:09.393]         }
  [07:07:09.393]         else {
  [07:07:09.393]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.393]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.393]         }
  [07:07:09.393]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.393]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.393]             base::sink(type = "output", split = FALSE)
  [07:07:09.393]             base::close(...future.stdout)
  [07:07:09.393]         }, add = TRUE)
  [07:07:09.393]     }
  [07:07:09.393]     ...future.frame <- base::sys.nframe()
  [07:07:09.393]     ...future.conditions <- base::list()
  [07:07:09.393]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.393]     ...future.result <- base::tryCatch({
  [07:07:09.393]         base::withCallingHandlers({
  [07:07:09.393]             ...future.value <- base::withVisible(base::local({
  [07:07:09.393]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.393]             }))
  [07:07:09.393]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.393]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.393]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.393]                 version = "1.8")
  [07:07:09.393]         }, condition = base::local({
  [07:07:09.393]             c <- base::c
  [07:07:09.393]             inherits <- base::inherits
  [07:07:09.393]             invokeRestart <- base::invokeRestart
  [07:07:09.393]             length <- base::length
  [07:07:09.393]             list <- base::list
  [07:07:09.393]             seq.int <- base::seq.int
  [07:07:09.393]             signalCondition <- base::signalCondition
  [07:07:09.393]             sys.calls <- base::sys.calls
  [07:07:09.393]             Sys.time <- base::Sys.time
  [07:07:09.393]             `[[` <- base::`[[`
  [07:07:09.393]             `+` <- base::`+`
  [07:07:09.393]             `<<-` <- base::`<<-`
  [07:07:09.393]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.393]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.393]                   3L)]
  [07:07:09.393]             }
  [07:07:09.393]             function(cond) {
  [07:07:09.393]                 if (inherits(cond, "error")) {
  [07:07:09.393]                   sessionInformation <- function() {
  [07:07:09.393]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.393]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.393]                       search = base::search(), system = base::Sys.info())
  [07:07:09.393]                   }
  [07:07:09.393]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.393]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.393]                     cond$call), session = sessionInformation(), 
  [07:07:09.393]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.393]                   signalCondition(cond)
  [07:07:09.393]                 }
  [07:07:09.393]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.393]                 ))) {
  [07:07:09.393]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.393]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.393]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.393]                   if (!signal) {
  [07:07:09.393]                     muffleCondition <- function (cond) 
  [07:07:09.393]                     {
  [07:07:09.393]                       inherits <- base::inherits
  [07:07:09.393]                       invokeRestart <- base::invokeRestart
  [07:07:09.393]                       muffled <- FALSE
  [07:07:09.393]                       if (inherits(cond, "message")) {
  [07:07:09.393]                         invokeRestart("muffleMessage")
  [07:07:09.393]                         muffled <- TRUE
  [07:07:09.393]                       }
  [07:07:09.393]                       else if (inherits(cond, "warning")) {
  [07:07:09.393]                         invokeRestart("muffleWarning")
  [07:07:09.393]                         muffled <- TRUE
  [07:07:09.393]                       }
  [07:07:09.393]                       else if (inherits(cond, "condition")) {
  [07:07:09.393]                         computeRestarts <- base::computeRestarts
  [07:07:09.393]                         grepl <- base::grepl
  [07:07:09.393]                         is.null <- base::is.null
  [07:07:09.393]                         restarts <- computeRestarts(cond)
  [07:07:09.393]                         for (restart in restarts) {
  [07:07:09.393]                           name <- restart$name
  [07:07:09.393]                           if (is.null(name)) 
  [07:07:09.393]                             next
  [07:07:09.393]                           if (!grepl("^muffle", name)) 
  [07:07:09.393]                             next
  [07:07:09.393]                           invokeRestart(restart)
  [07:07:09.393]                           muffled <- TRUE
  [07:07:09.393]                           break
  [07:07:09.393]                         }
  [07:07:09.393]                       }
  [07:07:09.393]                       invisible(muffled)
  [07:07:09.393]                     }
  [07:07:09.393]                     muffleCondition(cond)
  [07:07:09.393]                   }
  [07:07:09.393]                 }
  [07:07:09.393]             }
  [07:07:09.393]         }))
  [07:07:09.393]     }, error = function(ex) {
  [07:07:09.393]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.393]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.393]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.393]     }, finally = {
  [07:07:09.393]         {
  [07:07:09.393]             NULL
  [07:07:09.393]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.393]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.393]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.393]                 label = NULL, ...) 
  [07:07:09.393]             {
  [07:07:09.393]                 if (substitute) 
  [07:07:09.393]                   expr <- substitute(expr)
  [07:07:09.393]                 local <- as.logical(local)
  [07:07:09.393]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.393]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.393]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.393]                   label = label, ...)
  [07:07:09.393]                 if (!future$lazy) 
  [07:07:09.393]                   future <- run(future)
  [07:07:09.393]                 invisible(future)
  [07:07:09.393]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.393]         }
  [07:07:09.393]         base::options(...future.oldOptions)
  [07:07:09.393]     })
  [07:07:09.393]     Sys.time
  [07:07:09.393]     if (base::is.na(NA)) {
  [07:07:09.393]     }
  [07:07:09.393]     else {
  [07:07:09.393]         base::sink(type = "output", split = FALSE)
  [07:07:09.393]         if (NA) {
  [07:07:09.393]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.393]         }
  [07:07:09.393]         else {
  [07:07:09.393]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.393]         }
  [07:07:09.393]         base::close(...future.stdout)
  [07:07:09.393]         ...future.stdout <- NULL
  [07:07:09.393]     }
  [07:07:09.393]     ...future.result$conditions <- ...future.conditions
  [07:07:09.393]     ...future.result
  [07:07:09.393] }
  [07:07:09.402] plan(): Setting new future strategy stack:
  [07:07:09.405] List of future strategies:
  [07:07:09.405] 1. sequential:
  [07:07:09.405]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.405]    - tweaked: FALSE
  [07:07:09.405]    - call: NULL
  [07:07:09.409] plan(): nbrOfWorkers() = 1
  [07:07:09.413] plan(): Setting new future strategy stack:
  [07:07:09.417] List of future strategies:
  [07:07:09.417] 1. sequential:
  [07:07:09.417]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.417]    - tweaked: FALSE
  [07:07:09.417]    - call: NULL
  [07:07:09.421] plan(): nbrOfWorkers() = 1
  [07:07:09.424] SequentialFuture started (and completed)
  [07:07:09.428] plan(): Setting new future strategy stack:
  [07:07:09.431] List of future strategies:
  [07:07:09.431] 1. sequential:
  [07:07:09.431]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.431]    - tweaked: FALSE
  [07:07:09.431]    - call: NULL
  [07:07:09.434] plan(): nbrOfWorkers() = 1
  [07:07:09.437] SequentialFuture started (and completed)
  [07:07:09.442] Packages needed by the future expression (n = 0): <none>
  [07:07:09.445] Packages needed by future strategies (n = 0): <none>
  [07:07:09.453] {
  [07:07:09.453]     {
  [07:07:09.453]         ...future.startTime <- base::Sys.time()
  [07:07:09.453]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.453]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.453]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.453]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.453]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.453]         {
  [07:07:09.453]             {
  [07:07:09.453]                 base::local({
  [07:07:09.453]                   has_future <- base::requireNamespace("future", 
  [07:07:09.453]                     quietly = TRUE)
  [07:07:09.453]                   version <- if (has_future) 
  [07:07:09.453]                     utils::packageVersion("future")
  [07:07:09.453]                   else NULL
  [07:07:09.453]                   if (!has_future || version < "1.8.0") {
  [07:07:09.453]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.453]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.453]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.453]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.453]                         "release", "version")], collapse = " "), 
  [07:07:09.453]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.453]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.453]                       info)
  [07:07:09.453]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.453]                     if (!has_future) {
  [07:07:09.453]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.453]                         info)
  [07:07:09.453]                     }
  [07:07:09.453]                     else {
  [07:07:09.453]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.453]                         info, version)
  [07:07:09.453]                     }
  [07:07:09.453]                     base::stop(msg)
  [07:07:09.453]                   }
  [07:07:09.453]                 })
  [07:07:09.453]             }
  [07:07:09.453]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.453]         }
  [07:07:09.453]     }
  [07:07:09.453]     if (base::is.na(NA)) {
  [07:07:09.453]     }
  [07:07:09.453]     else {
  [07:07:09.453]         if (NA) {
  [07:07:09.453]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.453]                 open = "w")
  [07:07:09.453]         }
  [07:07:09.453]         else {
  [07:07:09.453]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.453]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.453]         }
  [07:07:09.453]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.453]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.453]             base::sink(type = "output", split = FALSE)
  [07:07:09.453]             base::close(...future.stdout)
  [07:07:09.453]         }, add = TRUE)
  [07:07:09.453]     }
  [07:07:09.453]     ...future.frame <- base::sys.nframe()
  [07:07:09.453]     ...future.conditions <- base::list()
  [07:07:09.453]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.453]     ...future.result <- base::tryCatch({
  [07:07:09.453]         base::withCallingHandlers({
  [07:07:09.453]             ...future.value <- base::withVisible(base::local({
  [07:07:09.453]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.453]             }))
  [07:07:09.453]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.453]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.453]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.453]                 version = "1.8")
  [07:07:09.453]         }, condition = base::local({
  [07:07:09.453]             c <- base::c
  [07:07:09.453]             inherits <- base::inherits
  [07:07:09.453]             invokeRestart <- base::invokeRestart
  [07:07:09.453]             length <- base::length
  [07:07:09.453]             list <- base::list
  [07:07:09.453]             seq.int <- base::seq.int
  [07:07:09.453]             signalCondition <- base::signalCondition
  [07:07:09.453]             sys.calls <- base::sys.calls
  [07:07:09.453]             Sys.time <- base::Sys.time
  [07:07:09.453]             `[[` <- base::`[[`
  [07:07:09.453]             `+` <- base::`+`
  [07:07:09.453]             `<<-` <- base::`<<-`
  [07:07:09.453]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.453]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.453]                   3L)]
  [07:07:09.453]             }
  [07:07:09.453]             function(cond) {
  [07:07:09.453]                 if (inherits(cond, "error")) {
  [07:07:09.453]                   sessionInformation <- function() {
  [07:07:09.453]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.453]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.453]                       search = base::search(), system = base::Sys.info())
  [07:07:09.453]                   }
  [07:07:09.453]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.453]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.453]                     cond$call), session = sessionInformation(), 
  [07:07:09.453]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.453]                   signalCondition(cond)
  [07:07:09.453]                 }
  [07:07:09.453]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.453]                 ))) {
  [07:07:09.453]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.453]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.453]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.453]                   if (!signal) {
  [07:07:09.453]                     muffleCondition <- function (cond) 
  [07:07:09.453]                     {
  [07:07:09.453]                       inherits <- base::inherits
  [07:07:09.453]                       invokeRestart <- base::invokeRestart
  [07:07:09.453]                       muffled <- FALSE
  [07:07:09.453]                       if (inherits(cond, "message")) {
  [07:07:09.453]                         invokeRestart("muffleMessage")
  [07:07:09.453]                         muffled <- TRUE
  [07:07:09.453]                       }
  [07:07:09.453]                       else if (inherits(cond, "warning")) {
  [07:07:09.453]                         invokeRestart("muffleWarning")
  [07:07:09.453]                         muffled <- TRUE
  [07:07:09.453]                       }
  [07:07:09.453]                       else if (inherits(cond, "condition")) {
  [07:07:09.453]                         computeRestarts <- base::computeRestarts
  [07:07:09.453]                         grepl <- base::grepl
  [07:07:09.453]                         is.null <- base::is.null
  [07:07:09.453]                         restarts <- computeRestarts(cond)
  [07:07:09.453]                         for (restart in restarts) {
  [07:07:09.453]                           name <- restart$name
  [07:07:09.453]                           if (is.null(name)) 
  [07:07:09.453]                             next
  [07:07:09.453]                           if (!grepl("^muffle", name)) 
  [07:07:09.453]                             next
  [07:07:09.453]                           invokeRestart(restart)
  [07:07:09.453]                           muffled <- TRUE
  [07:07:09.453]                           break
  [07:07:09.453]                         }
  [07:07:09.453]                       }
  [07:07:09.453]                       invisible(muffled)
  [07:07:09.453]                     }
  [07:07:09.453]                     muffleCondition(cond)
  [07:07:09.453]                   }
  [07:07:09.453]                 }
  [07:07:09.453]             }
  [07:07:09.453]         }))
  [07:07:09.453]     }, error = function(ex) {
  [07:07:09.453]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.453]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.453]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.453]     }, finally = {
  [07:07:09.453]         {
  [07:07:09.453]             NULL
  [07:07:09.453]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.453]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.453]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.453]                 label = NULL, ...) 
  [07:07:09.453]             {
  [07:07:09.453]                 if (substitute) 
  [07:07:09.453]                   expr <- substitute(expr)
  [07:07:09.453]                 local <- as.logical(local)
  [07:07:09.453]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.453]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.453]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.453]                   label = label, ...)
  [07:07:09.453]                 if (!future$lazy) 
  [07:07:09.453]                   future <- run(future)
  [07:07:09.453]                 invisible(future)
  [07:07:09.453]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.453]         }
  [07:07:09.453]         base::options(...future.oldOptions)
  [07:07:09.453]     })
  [07:07:09.453]     Sys.time
  [07:07:09.453]     if (base::is.na(NA)) {
  [07:07:09.453]     }
  [07:07:09.453]     else {
  [07:07:09.453]         base::sink(type = "output", split = FALSE)
  [07:07:09.453]         if (NA) {
  [07:07:09.453]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.453]         }
  [07:07:09.453]         else {
  [07:07:09.453]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.453]         }
  [07:07:09.453]         base::close(...future.stdout)
  [07:07:09.453]         ...future.stdout <- NULL
  [07:07:09.453]     }
  [07:07:09.453]     ...future.result$conditions <- ...future.conditions
  [07:07:09.453]     ...future.result
  [07:07:09.453] }
  [07:07:09.468] plan(): Setting new future strategy stack:
  [07:07:09.471] List of future strategies:
  [07:07:09.471] 1. sequential:
  [07:07:09.471]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.471]    - tweaked: FALSE
  [07:07:09.471]    - call: NULL
  [07:07:09.475] plan(): nbrOfWorkers() = 1
  [07:07:09.479] plan(): Setting new future strategy stack:
  [07:07:09.482] List of future strategies:
  [07:07:09.482] 1. sequential:
  [07:07:09.482]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.482]    - tweaked: FALSE
  [07:07:09.482]    - call: NULL
  [07:07:09.486] plan(): nbrOfWorkers() = 1
  [07:07:09.489] SequentialFuture started (and completed)
  [07:07:09.493] plan(): Setting new future strategy stack:
  [07:07:09.496] List of future strategies:
  [07:07:09.496] 1. sequential:
  [07:07:09.496]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.496]    - tweaked: FALSE
  [07:07:09.496]    - call: NULL
  [07:07:09.500] plan(): nbrOfWorkers() = 1
  [07:07:09.503] SequentialFuture started (and completed)
  [07:07:09.508] Packages needed by the future expression (n = 0): <none>
  [07:07:09.511] Packages needed by future strategies (n = 0): <none>
  [07:07:09.520] {
  [07:07:09.520]     {
  [07:07:09.520]         ...future.startTime <- base::Sys.time()
  [07:07:09.520]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.520]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.520]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.520]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.520]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.520]         {
  [07:07:09.520]             {
  [07:07:09.520]                 base::local({
  [07:07:09.520]                   has_future <- base::requireNamespace("future", 
  [07:07:09.520]                     quietly = TRUE)
  [07:07:09.520]                   version <- if (has_future) 
  [07:07:09.520]                     utils::packageVersion("future")
  [07:07:09.520]                   else NULL
  [07:07:09.520]                   if (!has_future || version < "1.8.0") {
  [07:07:09.520]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.520]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.520]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.520]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.520]                         "release", "version")], collapse = " "), 
  [07:07:09.520]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.520]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.520]                       info)
  [07:07:09.520]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.520]                     if (!has_future) {
  [07:07:09.520]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.520]                         info)
  [07:07:09.520]                     }
  [07:07:09.520]                     else {
  [07:07:09.520]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.520]                         info, version)
  [07:07:09.520]                     }
  [07:07:09.520]                     base::stop(msg)
  [07:07:09.520]                   }
  [07:07:09.520]                 })
  [07:07:09.520]             }
  [07:07:09.520]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.520]         }
  [07:07:09.520]     }
  [07:07:09.520]     if (base::is.na(NA)) {
  [07:07:09.520]     }
  [07:07:09.520]     else {
  [07:07:09.520]         if (NA) {
  [07:07:09.520]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.520]                 open = "w")
  [07:07:09.520]         }
  [07:07:09.520]         else {
  [07:07:09.520]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.520]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.520]         }
  [07:07:09.520]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.520]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.520]             base::sink(type = "output", split = FALSE)
  [07:07:09.520]             base::close(...future.stdout)
  [07:07:09.520]         }, add = TRUE)
  [07:07:09.520]     }
  [07:07:09.520]     ...future.frame <- base::sys.nframe()
  [07:07:09.520]     ...future.conditions <- base::list()
  [07:07:09.520]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.520]     ...future.result <- base::tryCatch({
  [07:07:09.520]         base::withCallingHandlers({
  [07:07:09.520]             ...future.value <- base::withVisible(base::local({
  [07:07:09.520]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.520]             }))
  [07:07:09.520]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.520]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.520]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.520]                 version = "1.8")
  [07:07:09.520]         }, condition = base::local({
  [07:07:09.520]             c <- base::c
  [07:07:09.520]             inherits <- base::inherits
  [07:07:09.520]             invokeRestart <- base::invokeRestart
  [07:07:09.520]             length <- base::length
  [07:07:09.520]             list <- base::list
  [07:07:09.520]             seq.int <- base::seq.int
  [07:07:09.520]             signalCondition <- base::signalCondition
  [07:07:09.520]             sys.calls <- base::sys.calls
  [07:07:09.520]             Sys.time <- base::Sys.time
  [07:07:09.520]             `[[` <- base::`[[`
  [07:07:09.520]             `+` <- base::`+`
  [07:07:09.520]             `<<-` <- base::`<<-`
  [07:07:09.520]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.520]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.520]                   3L)]
  [07:07:09.520]             }
  [07:07:09.520]             function(cond) {
  [07:07:09.520]                 if (inherits(cond, "error")) {
  [07:07:09.520]                   sessionInformation <- function() {
  [07:07:09.520]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.520]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.520]                       search = base::search(), system = base::Sys.info())
  [07:07:09.520]                   }
  [07:07:09.520]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.520]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.520]                     cond$call), session = sessionInformation(), 
  [07:07:09.520]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.520]                   signalCondition(cond)
  [07:07:09.520]                 }
  [07:07:09.520]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.520]                 ))) {
  [07:07:09.520]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.520]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.520]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.520]                   if (!signal) {
  [07:07:09.520]                     muffleCondition <- function (cond) 
  [07:07:09.520]                     {
  [07:07:09.520]                       inherits <- base::inherits
  [07:07:09.520]                       invokeRestart <- base::invokeRestart
  [07:07:09.520]                       muffled <- FALSE
  [07:07:09.520]                       if (inherits(cond, "message")) {
  [07:07:09.520]                         invokeRestart("muffleMessage")
  [07:07:09.520]                         muffled <- TRUE
  [07:07:09.520]                       }
  [07:07:09.520]                       else if (inherits(cond, "warning")) {
  [07:07:09.520]                         invokeRestart("muffleWarning")
  [07:07:09.520]                         muffled <- TRUE
  [07:07:09.520]                       }
  [07:07:09.520]                       else if (inherits(cond, "condition")) {
  [07:07:09.520]                         computeRestarts <- base::computeRestarts
  [07:07:09.520]                         grepl <- base::grepl
  [07:07:09.520]                         is.null <- base::is.null
  [07:07:09.520]                         restarts <- computeRestarts(cond)
  [07:07:09.520]                         for (restart in restarts) {
  [07:07:09.520]                           name <- restart$name
  [07:07:09.520]                           if (is.null(name)) 
  [07:07:09.520]                             next
  [07:07:09.520]                           if (!grepl("^muffle", name)) 
  [07:07:09.520]                             next
  [07:07:09.520]                           invokeRestart(restart)
  [07:07:09.520]                           muffled <- TRUE
  [07:07:09.520]                           break
  [07:07:09.520]                         }
  [07:07:09.520]                       }
  [07:07:09.520]                       invisible(muffled)
  [07:07:09.520]                     }
  [07:07:09.520]                     muffleCondition(cond)
  [07:07:09.520]                   }
  [07:07:09.520]                 }
  [07:07:09.520]             }
  [07:07:09.520]         }))
  [07:07:09.520]     }, error = function(ex) {
  [07:07:09.520]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.520]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.520]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.520]     }, finally = {
  [07:07:09.520]         {
  [07:07:09.520]             NULL
  [07:07:09.520]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.520]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.520]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.520]                 label = NULL, ...) 
  [07:07:09.520]             {
  [07:07:09.520]                 if (substitute) 
  [07:07:09.520]                   expr <- substitute(expr)
  [07:07:09.520]                 local <- as.logical(local)
  [07:07:09.520]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.520]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.520]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.520]                   label = label, ...)
  [07:07:09.520]                 if (!future$lazy) 
  [07:07:09.520]                   future <- run(future)
  [07:07:09.520]                 invisible(future)
  [07:07:09.520]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.520]         }
  [07:07:09.520]         base::options(...future.oldOptions)
  [07:07:09.520]     })
  [07:07:09.520]     Sys.time
  [07:07:09.520]     if (base::is.na(NA)) {
  [07:07:09.520]     }
  [07:07:09.520]     else {
  [07:07:09.520]         base::sink(type = "output", split = FALSE)
  [07:07:09.520]         if (NA) {
  [07:07:09.520]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.520]         }
  [07:07:09.520]         else {
  [07:07:09.520]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.520]         }
  [07:07:09.520]         base::close(...future.stdout)
  [07:07:09.520]         ...future.stdout <- NULL
  [07:07:09.520]     }
  [07:07:09.520]     ...future.result$conditions <- ...future.conditions
  [07:07:09.520]     ...future.result
  [07:07:09.520] }
  [07:07:09.529] plan(): Setting new future strategy stack:
  [07:07:09.532] List of future strategies:
  [07:07:09.532] 1. sequential:
  [07:07:09.532]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.532]    - tweaked: FALSE
  [07:07:09.532]    - call: NULL
  [07:07:09.536] plan(): nbrOfWorkers() = 1
  [07:07:09.540] plan(): Setting new future strategy stack:
  [07:07:09.543] List of future strategies:
  [07:07:09.543] 1. sequential:
  [07:07:09.543]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.543]    - tweaked: FALSE
  [07:07:09.543]    - call: NULL
  [07:07:09.546] plan(): nbrOfWorkers() = 1
  [07:07:09.549] SequentialFuture started (and completed)
  [07:07:09.553] plan(): Setting new future strategy stack:
  [07:07:09.555] List of future strategies:
  [07:07:09.555] 1. sequential:
  [07:07:09.555]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.555]    - tweaked: FALSE
  [07:07:09.555]    - call: NULL
  [07:07:09.559] plan(): nbrOfWorkers() = 1
  [07:07:09.562] SequentialFuture started (and completed)
  [07:07:09.567] Packages needed by the future expression (n = 0): <none>
  [07:07:09.569] Packages needed by future strategies (n = 0): <none>
  [07:07:09.578] {
  [07:07:09.578]     {
  [07:07:09.578]         ...future.startTime <- base::Sys.time()
  [07:07:09.578]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.578]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.578]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.578]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.578]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.578]         {
  [07:07:09.578]             {
  [07:07:09.578]                 base::local({
  [07:07:09.578]                   has_future <- base::requireNamespace("future", 
  [07:07:09.578]                     quietly = TRUE)
  [07:07:09.578]                   version <- if (has_future) 
  [07:07:09.578]                     utils::packageVersion("future")
  [07:07:09.578]                   else NULL
  [07:07:09.578]                   if (!has_future || version < "1.8.0") {
  [07:07:09.578]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.578]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.578]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.578]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.578]                         "release", "version")], collapse = " "), 
  [07:07:09.578]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.578]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.578]                       info)
  [07:07:09.578]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.578]                     if (!has_future) {
  [07:07:09.578]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.578]                         info)
  [07:07:09.578]                     }
  [07:07:09.578]                     else {
  [07:07:09.578]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.578]                         info, version)
  [07:07:09.578]                     }
  [07:07:09.578]                     base::stop(msg)
  [07:07:09.578]                   }
  [07:07:09.578]                 })
  [07:07:09.578]             }
  [07:07:09.578]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.578]         }
  [07:07:09.578]     }
  [07:07:09.578]     if (base::is.na(NA)) {
  [07:07:09.578]     }
  [07:07:09.578]     else {
  [07:07:09.578]         if (NA) {
  [07:07:09.578]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.578]                 open = "w")
  [07:07:09.578]         }
  [07:07:09.578]         else {
  [07:07:09.578]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.578]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.578]         }
  [07:07:09.578]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.578]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.578]             base::sink(type = "output", split = FALSE)
  [07:07:09.578]             base::close(...future.stdout)
  [07:07:09.578]         }, add = TRUE)
  [07:07:09.578]     }
  [07:07:09.578]     ...future.frame <- base::sys.nframe()
  [07:07:09.578]     ...future.conditions <- base::list()
  [07:07:09.578]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.578]     ...future.result <- base::tryCatch({
  [07:07:09.578]         base::withCallingHandlers({
  [07:07:09.578]             ...future.value <- base::withVisible(base::local({
  [07:07:09.578]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.578]             }))
  [07:07:09.578]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.578]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.578]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.578]                 version = "1.8")
  [07:07:09.578]         }, condition = base::local({
  [07:07:09.578]             c <- base::c
  [07:07:09.578]             inherits <- base::inherits
  [07:07:09.578]             invokeRestart <- base::invokeRestart
  [07:07:09.578]             length <- base::length
  [07:07:09.578]             list <- base::list
  [07:07:09.578]             seq.int <- base::seq.int
  [07:07:09.578]             signalCondition <- base::signalCondition
  [07:07:09.578]             sys.calls <- base::sys.calls
  [07:07:09.578]             Sys.time <- base::Sys.time
  [07:07:09.578]             `[[` <- base::`[[`
  [07:07:09.578]             `+` <- base::`+`
  [07:07:09.578]             `<<-` <- base::`<<-`
  [07:07:09.578]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.578]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.578]                   3L)]
  [07:07:09.578]             }
  [07:07:09.578]             function(cond) {
  [07:07:09.578]                 if (inherits(cond, "error")) {
  [07:07:09.578]                   sessionInformation <- function() {
  [07:07:09.578]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.578]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.578]                       search = base::search(), system = base::Sys.info())
  [07:07:09.578]                   }
  [07:07:09.578]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.578]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.578]                     cond$call), session = sessionInformation(), 
  [07:07:09.578]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.578]                   signalCondition(cond)
  [07:07:09.578]                 }
  [07:07:09.578]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.578]                 ))) {
  [07:07:09.578]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.578]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.578]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.578]                   if (!signal) {
  [07:07:09.578]                     muffleCondition <- function (cond) 
  [07:07:09.578]                     {
  [07:07:09.578]                       inherits <- base::inherits
  [07:07:09.578]                       invokeRestart <- base::invokeRestart
  [07:07:09.578]                       muffled <- FALSE
  [07:07:09.578]                       if (inherits(cond, "message")) {
  [07:07:09.578]                         invokeRestart("muffleMessage")
  [07:07:09.578]                         muffled <- TRUE
  [07:07:09.578]                       }
  [07:07:09.578]                       else if (inherits(cond, "warning")) {
  [07:07:09.578]                         invokeRestart("muffleWarning")
  [07:07:09.578]                         muffled <- TRUE
  [07:07:09.578]                       }
  [07:07:09.578]                       else if (inherits(cond, "condition")) {
  [07:07:09.578]                         computeRestarts <- base::computeRestarts
  [07:07:09.578]                         grepl <- base::grepl
  [07:07:09.578]                         is.null <- base::is.null
  [07:07:09.578]                         restarts <- computeRestarts(cond)
  [07:07:09.578]                         for (restart in restarts) {
  [07:07:09.578]                           name <- restart$name
  [07:07:09.578]                           if (is.null(name)) 
  [07:07:09.578]                             next
  [07:07:09.578]                           if (!grepl("^muffle", name)) 
  [07:07:09.578]                             next
  [07:07:09.578]                           invokeRestart(restart)
  [07:07:09.578]                           muffled <- TRUE
  [07:07:09.578]                           break
  [07:07:09.578]                         }
  [07:07:09.578]                       }
  [07:07:09.578]                       invisible(muffled)
  [07:07:09.578]                     }
  [07:07:09.578]                     muffleCondition(cond)
  [07:07:09.578]                   }
  [07:07:09.578]                 }
  [07:07:09.578]             }
  [07:07:09.578]         }))
  [07:07:09.578]     }, error = function(ex) {
  [07:07:09.578]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.578]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.578]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.578]     }, finally = {
  [07:07:09.578]         {
  [07:07:09.578]             NULL
  [07:07:09.578]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.578]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.578]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.578]                 label = NULL, ...) 
  [07:07:09.578]             {
  [07:07:09.578]                 if (substitute) 
  [07:07:09.578]                   expr <- substitute(expr)
  [07:07:09.578]                 local <- as.logical(local)
  [07:07:09.578]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.578]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.578]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.578]                   label = label, ...)
  [07:07:09.578]                 if (!future$lazy) 
  [07:07:09.578]                   future <- run(future)
  [07:07:09.578]                 invisible(future)
  [07:07:09.578]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.578]         }
  [07:07:09.578]         base::options(...future.oldOptions)
  [07:07:09.578]     })
  [07:07:09.578]     Sys.time
  [07:07:09.578]     if (base::is.na(NA)) {
  [07:07:09.578]     }
  [07:07:09.578]     else {
  [07:07:09.578]         base::sink(type = "output", split = FALSE)
  [07:07:09.578]         if (NA) {
  [07:07:09.578]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.578]         }
  [07:07:09.578]         else {
  [07:07:09.578]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.578]         }
  [07:07:09.578]         base::close(...future.stdout)
  [07:07:09.578]         ...future.stdout <- NULL
  [07:07:09.578]     }
  [07:07:09.578]     ...future.result$conditions <- ...future.conditions
  [07:07:09.578]     ...future.result
  [07:07:09.578] }
  [07:07:09.588] plan(): Setting new future strategy stack:
  [07:07:09.591] List of future strategies:
  [07:07:09.591] 1. sequential:
  [07:07:09.591]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.591]    - tweaked: FALSE
  [07:07:09.591]    - call: NULL
  [07:07:09.594] plan(): nbrOfWorkers() = 1
  [07:07:09.598] plan(): Setting new future strategy stack:
  [07:07:09.602] List of future strategies:
  [07:07:09.602] 1. sequential:
  [07:07:09.602]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.602]    - tweaked: FALSE
  [07:07:09.602]    - call: NULL
  [07:07:09.606] plan(): nbrOfWorkers() = 1
  [07:07:09.609] SequentialFuture started (and completed)
  [07:07:09.613] plan(): Setting new future strategy stack:
  [07:07:09.615] List of future strategies:
  [07:07:09.615] 1. sequential:
  [07:07:09.615]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.615]    - tweaked: FALSE
  [07:07:09.615]    - call: NULL
  [07:07:09.619] plan(): nbrOfWorkers() = 1
  [07:07:09.621] SequentialFuture started (and completed)
  [07:07:09.623] Packages needed by the future expression (n = 0): <none>
  [07:07:09.628] Packages needed by future strategies (n = 0): <none>
  [07:07:09.633] {
  [07:07:09.633]     {
  [07:07:09.633]         ...future.startTime <- base::Sys.time()
  [07:07:09.633]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.633]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.633]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.633]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.633]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.633]         {
  [07:07:09.633]             {
  [07:07:09.633]                 base::local({
  [07:07:09.633]                   has_future <- base::requireNamespace("future", 
  [07:07:09.633]                     quietly = TRUE)
  [07:07:09.633]                   version <- if (has_future) 
  [07:07:09.633]                     utils::packageVersion("future")
  [07:07:09.633]                   else NULL
  [07:07:09.633]                   if (!has_future || version < "1.8.0") {
  [07:07:09.633]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.633]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.633]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.633]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.633]                         "release", "version")], collapse = " "), 
  [07:07:09.633]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.633]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.633]                       info)
  [07:07:09.633]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.633]                     if (!has_future) {
  [07:07:09.633]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.633]                         info)
  [07:07:09.633]                     }
  [07:07:09.633]                     else {
  [07:07:09.633]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.633]                         info, version)
  [07:07:09.633]                     }
  [07:07:09.633]                     base::stop(msg)
  [07:07:09.633]                   }
  [07:07:09.633]                 })
  [07:07:09.633]             }
  [07:07:09.633]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.633]         }
  [07:07:09.633]     }
  [07:07:09.633]     if (base::is.na(NA)) {
  [07:07:09.633]     }
  [07:07:09.633]     else {
  [07:07:09.633]         if (NA) {
  [07:07:09.633]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.633]                 open = "w")
  [07:07:09.633]         }
  [07:07:09.633]         else {
  [07:07:09.633]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.633]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.633]         }
  [07:07:09.633]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.633]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.633]             base::sink(type = "output", split = FALSE)
  [07:07:09.633]             base::close(...future.stdout)
  [07:07:09.633]         }, add = TRUE)
  [07:07:09.633]     }
  [07:07:09.633]     ...future.frame <- base::sys.nframe()
  [07:07:09.633]     ...future.conditions <- base::list()
  [07:07:09.633]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.633]     ...future.result <- base::tryCatch({
  [07:07:09.633]         base::withCallingHandlers({
  [07:07:09.633]             ...future.value <- base::withVisible(base::local({
  [07:07:09.633]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.633]             }))
  [07:07:09.633]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.633]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.633]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.633]                 version = "1.8")
  [07:07:09.633]         }, condition = base::local({
  [07:07:09.633]             c <- base::c
  [07:07:09.633]             inherits <- base::inherits
  [07:07:09.633]             invokeRestart <- base::invokeRestart
  [07:07:09.633]             length <- base::length
  [07:07:09.633]             list <- base::list
  [07:07:09.633]             seq.int <- base::seq.int
  [07:07:09.633]             signalCondition <- base::signalCondition
  [07:07:09.633]             sys.calls <- base::sys.calls
  [07:07:09.633]             Sys.time <- base::Sys.time
  [07:07:09.633]             `[[` <- base::`[[`
  [07:07:09.633]             `+` <- base::`+`
  [07:07:09.633]             `<<-` <- base::`<<-`
  [07:07:09.633]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.633]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.633]                   3L)]
  [07:07:09.633]             }
  [07:07:09.633]             function(cond) {
  [07:07:09.633]                 if (inherits(cond, "error")) {
  [07:07:09.633]                   sessionInformation <- function() {
  [07:07:09.633]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.633]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.633]                       search = base::search(), system = base::Sys.info())
  [07:07:09.633]                   }
  [07:07:09.633]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.633]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.633]                     cond$call), session = sessionInformation(), 
  [07:07:09.633]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.633]                   signalCondition(cond)
  [07:07:09.633]                 }
  [07:07:09.633]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.633]                 ))) {
  [07:07:09.633]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.633]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.633]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.633]                   if (!signal) {
  [07:07:09.633]                     muffleCondition <- function (cond) 
  [07:07:09.633]                     {
  [07:07:09.633]                       inherits <- base::inherits
  [07:07:09.633]                       invokeRestart <- base::invokeRestart
  [07:07:09.633]                       muffled <- FALSE
  [07:07:09.633]                       if (inherits(cond, "message")) {
  [07:07:09.633]                         invokeRestart("muffleMessage")
  [07:07:09.633]                         muffled <- TRUE
  [07:07:09.633]                       }
  [07:07:09.633]                       else if (inherits(cond, "warning")) {
  [07:07:09.633]                         invokeRestart("muffleWarning")
  [07:07:09.633]                         muffled <- TRUE
  [07:07:09.633]                       }
  [07:07:09.633]                       else if (inherits(cond, "condition")) {
  [07:07:09.633]                         computeRestarts <- base::computeRestarts
  [07:07:09.633]                         grepl <- base::grepl
  [07:07:09.633]                         is.null <- base::is.null
  [07:07:09.633]                         restarts <- computeRestarts(cond)
  [07:07:09.633]                         for (restart in restarts) {
  [07:07:09.633]                           name <- restart$name
  [07:07:09.633]                           if (is.null(name)) 
  [07:07:09.633]                             next
  [07:07:09.633]                           if (!grepl("^muffle", name)) 
  [07:07:09.633]                             next
  [07:07:09.633]                           invokeRestart(restart)
  [07:07:09.633]                           muffled <- TRUE
  [07:07:09.633]                           break
  [07:07:09.633]                         }
  [07:07:09.633]                       }
  [07:07:09.633]                       invisible(muffled)
  [07:07:09.633]                     }
  [07:07:09.633]                     muffleCondition(cond)
  [07:07:09.633]                   }
  [07:07:09.633]                 }
  [07:07:09.633]             }
  [07:07:09.633]         }))
  [07:07:09.633]     }, error = function(ex) {
  [07:07:09.633]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.633]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.633]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.633]     }, finally = {
  [07:07:09.633]         {
  [07:07:09.633]             NULL
  [07:07:09.633]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.633]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.633]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.633]                 label = NULL, ...) 
  [07:07:09.633]             {
  [07:07:09.633]                 if (substitute) 
  [07:07:09.633]                   expr <- substitute(expr)
  [07:07:09.633]                 local <- as.logical(local)
  [07:07:09.633]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.633]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.633]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.633]                   label = label, ...)
  [07:07:09.633]                 if (!future$lazy) 
  [07:07:09.633]                   future <- run(future)
  [07:07:09.633]                 invisible(future)
  [07:07:09.633]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.633]         }
  [07:07:09.633]         base::options(...future.oldOptions)
  [07:07:09.633]     })
  [07:07:09.633]     Sys.time
  [07:07:09.633]     if (base::is.na(NA)) {
  [07:07:09.633]     }
  [07:07:09.633]     else {
  [07:07:09.633]         base::sink(type = "output", split = FALSE)
  [07:07:09.633]         if (NA) {
  [07:07:09.633]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.633]         }
  [07:07:09.633]         else {
  [07:07:09.633]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.633]         }
  [07:07:09.633]         base::close(...future.stdout)
  [07:07:09.633]         ...future.stdout <- NULL
  [07:07:09.633]     }
  [07:07:09.633]     ...future.result$conditions <- ...future.conditions
  [07:07:09.633]     ...future.result
  [07:07:09.633] }
  [07:07:09.642] plan(): Setting new future strategy stack:
  [07:07:09.645] List of future strategies:
  [07:07:09.645] 1. sequential:
  [07:07:09.645]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.645]    - tweaked: FALSE
  [07:07:09.645]    - call: NULL
  [07:07:09.649] plan(): nbrOfWorkers() = 1
  [07:07:09.652] plan(): Setting new future strategy stack:
  [07:07:09.655] List of future strategies:
  [07:07:09.655] 1. sequential:
  [07:07:09.655]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.655]    - tweaked: FALSE
  [07:07:09.655]    - call: NULL
  [07:07:09.659] plan(): nbrOfWorkers() = 1
  [07:07:09.661] SequentialFuture started (and completed)
  [07:07:09.665] plan(): Setting new future strategy stack:
  [07:07:09.667] List of future strategies:
  [07:07:09.667] 1. sequential:
  [07:07:09.667]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.667]    - tweaked: FALSE
  [07:07:09.667]    - call: NULL
  [07:07:09.670] plan(): nbrOfWorkers() = 1
  [07:07:09.672] SequentialFuture started (and completed)
  [07:07:09.677] Packages needed by the future expression (n = 0): <none>
  [07:07:09.680] Packages needed by future strategies (n = 0): <none>
  [07:07:09.690] {
  [07:07:09.690]     {
  [07:07:09.690]         ...future.startTime <- base::Sys.time()
  [07:07:09.690]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.690]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.690]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.690]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.690]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.690]         {
  [07:07:09.690]             {
  [07:07:09.690]                 base::local({
  [07:07:09.690]                   has_future <- base::requireNamespace("future", 
  [07:07:09.690]                     quietly = TRUE)
  [07:07:09.690]                   version <- if (has_future) 
  [07:07:09.690]                     utils::packageVersion("future")
  [07:07:09.690]                   else NULL
  [07:07:09.690]                   if (!has_future || version < "1.8.0") {
  [07:07:09.690]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.690]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.690]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.690]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.690]                         "release", "version")], collapse = " "), 
  [07:07:09.690]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.690]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.690]                       info)
  [07:07:09.690]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.690]                     if (!has_future) {
  [07:07:09.690]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.690]                         info)
  [07:07:09.690]                     }
  [07:07:09.690]                     else {
  [07:07:09.690]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.690]                         info, version)
  [07:07:09.690]                     }
  [07:07:09.690]                     base::stop(msg)
  [07:07:09.690]                   }
  [07:07:09.690]                 })
  [07:07:09.690]             }
  [07:07:09.690]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.690]         }
  [07:07:09.690]     }
  [07:07:09.690]     if (base::is.na(NA)) {
  [07:07:09.690]     }
  [07:07:09.690]     else {
  [07:07:09.690]         if (NA) {
  [07:07:09.690]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.690]                 open = "w")
  [07:07:09.690]         }
  [07:07:09.690]         else {
  [07:07:09.690]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.690]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.690]         }
  [07:07:09.690]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.690]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.690]             base::sink(type = "output", split = FALSE)
  [07:07:09.690]             base::close(...future.stdout)
  [07:07:09.690]         }, add = TRUE)
  [07:07:09.690]     }
  [07:07:09.690]     ...future.frame <- base::sys.nframe()
  [07:07:09.690]     ...future.conditions <- base::list()
  [07:07:09.690]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.690]     ...future.result <- base::tryCatch({
  [07:07:09.690]         base::withCallingHandlers({
  [07:07:09.690]             ...future.value <- base::withVisible(base::local({
  [07:07:09.690]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.690]             }))
  [07:07:09.690]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.690]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.690]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.690]                 version = "1.8")
  [07:07:09.690]         }, condition = base::local({
  [07:07:09.690]             c <- base::c
  [07:07:09.690]             inherits <- base::inherits
  [07:07:09.690]             invokeRestart <- base::invokeRestart
  [07:07:09.690]             length <- base::length
  [07:07:09.690]             list <- base::list
  [07:07:09.690]             seq.int <- base::seq.int
  [07:07:09.690]             signalCondition <- base::signalCondition
  [07:07:09.690]             sys.calls <- base::sys.calls
  [07:07:09.690]             Sys.time <- base::Sys.time
  [07:07:09.690]             `[[` <- base::`[[`
  [07:07:09.690]             `+` <- base::`+`
  [07:07:09.690]             `<<-` <- base::`<<-`
  [07:07:09.690]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.690]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.690]                   3L)]
  [07:07:09.690]             }
  [07:07:09.690]             function(cond) {
  [07:07:09.690]                 if (inherits(cond, "error")) {
  [07:07:09.690]                   sessionInformation <- function() {
  [07:07:09.690]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.690]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.690]                       search = base::search(), system = base::Sys.info())
  [07:07:09.690]                   }
  [07:07:09.690]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.690]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.690]                     cond$call), session = sessionInformation(), 
  [07:07:09.690]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.690]                   signalCondition(cond)
  [07:07:09.690]                 }
  [07:07:09.690]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.690]                 ))) {
  [07:07:09.690]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.690]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.690]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.690]                   if (!signal) {
  [07:07:09.690]                     muffleCondition <- function (cond) 
  [07:07:09.690]                     {
  [07:07:09.690]                       inherits <- base::inherits
  [07:07:09.690]                       invokeRestart <- base::invokeRestart
  [07:07:09.690]                       muffled <- FALSE
  [07:07:09.690]                       if (inherits(cond, "message")) {
  [07:07:09.690]                         invokeRestart("muffleMessage")
  [07:07:09.690]                         muffled <- TRUE
  [07:07:09.690]                       }
  [07:07:09.690]                       else if (inherits(cond, "warning")) {
  [07:07:09.690]                         invokeRestart("muffleWarning")
  [07:07:09.690]                         muffled <- TRUE
  [07:07:09.690]                       }
  [07:07:09.690]                       else if (inherits(cond, "condition")) {
  [07:07:09.690]                         computeRestarts <- base::computeRestarts
  [07:07:09.690]                         grepl <- base::grepl
  [07:07:09.690]                         is.null <- base::is.null
  [07:07:09.690]                         restarts <- computeRestarts(cond)
  [07:07:09.690]                         for (restart in restarts) {
  [07:07:09.690]                           name <- restart$name
  [07:07:09.690]                           if (is.null(name)) 
  [07:07:09.690]                             next
  [07:07:09.690]                           if (!grepl("^muffle", name)) 
  [07:07:09.690]                             next
  [07:07:09.690]                           invokeRestart(restart)
  [07:07:09.690]                           muffled <- TRUE
  [07:07:09.690]                           break
  [07:07:09.690]                         }
  [07:07:09.690]                       }
  [07:07:09.690]                       invisible(muffled)
  [07:07:09.690]                     }
  [07:07:09.690]                     muffleCondition(cond)
  [07:07:09.690]                   }
  [07:07:09.690]                 }
  [07:07:09.690]             }
  [07:07:09.690]         }))
  [07:07:09.690]     }, error = function(ex) {
  [07:07:09.690]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.690]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.690]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.690]     }, finally = {
  [07:07:09.690]         {
  [07:07:09.690]             NULL
  [07:07:09.690]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.690]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.690]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.690]                 label = NULL, ...) 
  [07:07:09.690]             {
  [07:07:09.690]                 if (substitute) 
  [07:07:09.690]                   expr <- substitute(expr)
  [07:07:09.690]                 local <- as.logical(local)
  [07:07:09.690]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.690]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.690]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.690]                   label = label, ...)
  [07:07:09.690]                 if (!future$lazy) 
  [07:07:09.690]                   future <- run(future)
  [07:07:09.690]                 invisible(future)
  [07:07:09.690]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.690]         }
  [07:07:09.690]         base::options(...future.oldOptions)
  [07:07:09.690]     })
  [07:07:09.690]     Sys.time
  [07:07:09.690]     if (base::is.na(NA)) {
  [07:07:09.690]     }
  [07:07:09.690]     else {
  [07:07:09.690]         base::sink(type = "output", split = FALSE)
  [07:07:09.690]         if (NA) {
  [07:07:09.690]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.690]         }
  [07:07:09.690]         else {
  [07:07:09.690]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.690]         }
  [07:07:09.690]         base::close(...future.stdout)
  [07:07:09.690]         ...future.stdout <- NULL
  [07:07:09.690]     }
  [07:07:09.690]     ...future.result$conditions <- ...future.conditions
  [07:07:09.690]     ...future.result
  [07:07:09.690] }
  [07:07:09.700] plan(): Setting new future strategy stack:
  [07:07:09.702] List of future strategies:
  [07:07:09.702] 1. sequential:
  [07:07:09.702]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.702]    - tweaked: FALSE
  [07:07:09.702]    - call: NULL
  [07:07:09.705] plan(): nbrOfWorkers() = 1
  [07:07:09.709] plan(): Setting new future strategy stack:
  [07:07:09.711] List of future strategies:
  [07:07:09.711] 1. sequential:
  [07:07:09.711]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.711]    - tweaked: FALSE
  [07:07:09.711]    - call: NULL
  [07:07:09.714] plan(): nbrOfWorkers() = 1
  [07:07:09.717] SequentialFuture started (and completed)
  [07:07:09.720] plan(): Setting new future strategy stack:
  [07:07:09.722] List of future strategies:
  [07:07:09.722] 1. sequential:
  [07:07:09.722]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.722]    - tweaked: FALSE
  [07:07:09.722]    - call: NULL
  [07:07:09.725] plan(): nbrOfWorkers() = 1
  [07:07:09.727] SequentialFuture started (and completed)
  [07:07:09.732] Packages needed by the future expression (n = 0): <none>
  [07:07:09.734] Packages needed by future strategies (n = 0): <none>
  [07:07:09.743] {
  [07:07:09.743]     {
  [07:07:09.743]         ...future.startTime <- base::Sys.time()
  [07:07:09.743]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.743]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.743]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.743]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.743]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.743]         {
  [07:07:09.743]             {
  [07:07:09.743]                 base::local({
  [07:07:09.743]                   has_future <- base::requireNamespace("future", 
  [07:07:09.743]                     quietly = TRUE)
  [07:07:09.743]                   version <- if (has_future) 
  [07:07:09.743]                     utils::packageVersion("future")
  [07:07:09.743]                   else NULL
  [07:07:09.743]                   if (!has_future || version < "1.8.0") {
  [07:07:09.743]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.743]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.743]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.743]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.743]                         "release", "version")], collapse = " "), 
  [07:07:09.743]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.743]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.743]                       info)
  [07:07:09.743]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.743]                     if (!has_future) {
  [07:07:09.743]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.743]                         info)
  [07:07:09.743]                     }
  [07:07:09.743]                     else {
  [07:07:09.743]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.743]                         info, version)
  [07:07:09.743]                     }
  [07:07:09.743]                     base::stop(msg)
  [07:07:09.743]                   }
  [07:07:09.743]                 })
  [07:07:09.743]             }
  [07:07:09.743]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.743]         }
  [07:07:09.743]     }
  [07:07:09.743]     if (base::is.na(NA)) {
  [07:07:09.743]     }
  [07:07:09.743]     else {
  [07:07:09.743]         if (NA) {
  [07:07:09.743]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.743]                 open = "w")
  [07:07:09.743]         }
  [07:07:09.743]         else {
  [07:07:09.743]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.743]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.743]         }
  [07:07:09.743]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.743]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.743]             base::sink(type = "output", split = FALSE)
  [07:07:09.743]             base::close(...future.stdout)
  [07:07:09.743]         }, add = TRUE)
  [07:07:09.743]     }
  [07:07:09.743]     ...future.frame <- base::sys.nframe()
  [07:07:09.743]     ...future.conditions <- base::list()
  [07:07:09.743]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.743]     ...future.result <- base::tryCatch({
  [07:07:09.743]         base::withCallingHandlers({
  [07:07:09.743]             ...future.value <- base::withVisible(base::local({
  [07:07:09.743]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.743]             }))
  [07:07:09.743]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.743]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.743]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.743]                 version = "1.8")
  [07:07:09.743]         }, condition = base::local({
  [07:07:09.743]             c <- base::c
  [07:07:09.743]             inherits <- base::inherits
  [07:07:09.743]             invokeRestart <- base::invokeRestart
  [07:07:09.743]             length <- base::length
  [07:07:09.743]             list <- base::list
  [07:07:09.743]             seq.int <- base::seq.int
  [07:07:09.743]             signalCondition <- base::signalCondition
  [07:07:09.743]             sys.calls <- base::sys.calls
  [07:07:09.743]             Sys.time <- base::Sys.time
  [07:07:09.743]             `[[` <- base::`[[`
  [07:07:09.743]             `+` <- base::`+`
  [07:07:09.743]             `<<-` <- base::`<<-`
  [07:07:09.743]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.743]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.743]                   3L)]
  [07:07:09.743]             }
  [07:07:09.743]             function(cond) {
  [07:07:09.743]                 if (inherits(cond, "error")) {
  [07:07:09.743]                   sessionInformation <- function() {
  [07:07:09.743]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.743]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.743]                       search = base::search(), system = base::Sys.info())
  [07:07:09.743]                   }
  [07:07:09.743]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.743]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.743]                     cond$call), session = sessionInformation(), 
  [07:07:09.743]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.743]                   signalCondition(cond)
  [07:07:09.743]                 }
  [07:07:09.743]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.743]                 ))) {
  [07:07:09.743]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.743]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.743]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.743]                   if (!signal) {
  [07:07:09.743]                     muffleCondition <- function (cond) 
  [07:07:09.743]                     {
  [07:07:09.743]                       inherits <- base::inherits
  [07:07:09.743]                       invokeRestart <- base::invokeRestart
  [07:07:09.743]                       muffled <- FALSE
  [07:07:09.743]                       if (inherits(cond, "message")) {
  [07:07:09.743]                         invokeRestart("muffleMessage")
  [07:07:09.743]                         muffled <- TRUE
  [07:07:09.743]                       }
  [07:07:09.743]                       else if (inherits(cond, "warning")) {
  [07:07:09.743]                         invokeRestart("muffleWarning")
  [07:07:09.743]                         muffled <- TRUE
  [07:07:09.743]                       }
  [07:07:09.743]                       else if (inherits(cond, "condition")) {
  [07:07:09.743]                         computeRestarts <- base::computeRestarts
  [07:07:09.743]                         grepl <- base::grepl
  [07:07:09.743]                         is.null <- base::is.null
  [07:07:09.743]                         restarts <- computeRestarts(cond)
  [07:07:09.743]                         for (restart in restarts) {
  [07:07:09.743]                           name <- restart$name
  [07:07:09.743]                           if (is.null(name)) 
  [07:07:09.743]                             next
  [07:07:09.743]                           if (!grepl("^muffle", name)) 
  [07:07:09.743]                             next
  [07:07:09.743]                           invokeRestart(restart)
  [07:07:09.743]                           muffled <- TRUE
  [07:07:09.743]                           break
  [07:07:09.743]                         }
  [07:07:09.743]                       }
  [07:07:09.743]                       invisible(muffled)
  [07:07:09.743]                     }
  [07:07:09.743]                     muffleCondition(cond)
  [07:07:09.743]                   }
  [07:07:09.743]                 }
  [07:07:09.743]             }
  [07:07:09.743]         }))
  [07:07:09.743]     }, error = function(ex) {
  [07:07:09.743]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.743]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.743]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.743]     }, finally = {
  [07:07:09.743]         {
  [07:07:09.743]             NULL
  [07:07:09.743]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.743]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.743]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.743]                 label = NULL, ...) 
  [07:07:09.743]             {
  [07:07:09.743]                 if (substitute) 
  [07:07:09.743]                   expr <- substitute(expr)
  [07:07:09.743]                 local <- as.logical(local)
  [07:07:09.743]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.743]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.743]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.743]                   label = label, ...)
  [07:07:09.743]                 if (!future$lazy) 
  [07:07:09.743]                   future <- run(future)
  [07:07:09.743]                 invisible(future)
  [07:07:09.743]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.743]         }
  [07:07:09.743]         base::options(...future.oldOptions)
  [07:07:09.743]     })
  [07:07:09.743]     Sys.time
  [07:07:09.743]     if (base::is.na(NA)) {
  [07:07:09.743]     }
  [07:07:09.743]     else {
  [07:07:09.743]         base::sink(type = "output", split = FALSE)
  [07:07:09.743]         if (NA) {
  [07:07:09.743]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.743]         }
  [07:07:09.743]         else {
  [07:07:09.743]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.743]         }
  [07:07:09.743]         base::close(...future.stdout)
  [07:07:09.743]         ...future.stdout <- NULL
  [07:07:09.743]     }
  [07:07:09.743]     ...future.result$conditions <- ...future.conditions
  [07:07:09.743]     ...future.result
  [07:07:09.743] }
  [07:07:09.752] plan(): Setting new future strategy stack:
  [07:07:09.754] List of future strategies:
  [07:07:09.754] 1. sequential:
  [07:07:09.754]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.754]    - tweaked: FALSE
  [07:07:09.754]    - call: NULL
  [07:07:09.758] plan(): nbrOfWorkers() = 1
  [07:07:09.761] plan(): Setting new future strategy stack:
  [07:07:09.763] List of future strategies:
  [07:07:09.763] 1. sequential:
  [07:07:09.763]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.763]    - tweaked: FALSE
  [07:07:09.763]    - call: NULL
  [07:07:09.771] plan(): nbrOfWorkers() = 1
  [07:07:09.773] SequentialFuture started (and completed)
  [07:07:09.777] plan(): Setting new future strategy stack:
  [07:07:09.779] List of future strategies:
  [07:07:09.779] 1. sequential:
  [07:07:09.779]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.779]    - tweaked: FALSE
  [07:07:09.779]    - call: NULL
  [07:07:09.784] plan(): nbrOfWorkers() = 1
  [07:07:09.786] SequentialFuture started (and completed)
  [07:07:09.791] Packages needed by the future expression (n = 0): <none>
  [07:07:09.793] Packages needed by future strategies (n = 0): <none>
  [07:07:09.802] {
  [07:07:09.802]     {
  [07:07:09.802]         ...future.startTime <- base::Sys.time()
  [07:07:09.802]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.802]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.802]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.802]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.802]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.802]         {
  [07:07:09.802]             {
  [07:07:09.802]                 base::local({
  [07:07:09.802]                   has_future <- base::requireNamespace("future", 
  [07:07:09.802]                     quietly = TRUE)
  [07:07:09.802]                   version <- if (has_future) 
  [07:07:09.802]                     utils::packageVersion("future")
  [07:07:09.802]                   else NULL
  [07:07:09.802]                   if (!has_future || version < "1.8.0") {
  [07:07:09.802]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.802]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.802]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.802]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.802]                         "release", "version")], collapse = " "), 
  [07:07:09.802]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.802]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.802]                       info)
  [07:07:09.802]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.802]                     if (!has_future) {
  [07:07:09.802]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.802]                         info)
  [07:07:09.802]                     }
  [07:07:09.802]                     else {
  [07:07:09.802]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.802]                         info, version)
  [07:07:09.802]                     }
  [07:07:09.802]                     base::stop(msg)
  [07:07:09.802]                   }
  [07:07:09.802]                 })
  [07:07:09.802]             }
  [07:07:09.802]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.802]         }
  [07:07:09.802]     }
  [07:07:09.802]     if (base::is.na(NA)) {
  [07:07:09.802]     }
  [07:07:09.802]     else {
  [07:07:09.802]         if (NA) {
  [07:07:09.802]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.802]                 open = "w")
  [07:07:09.802]         }
  [07:07:09.802]         else {
  [07:07:09.802]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.802]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.802]         }
  [07:07:09.802]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.802]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.802]             base::sink(type = "output", split = FALSE)
  [07:07:09.802]             base::close(...future.stdout)
  [07:07:09.802]         }, add = TRUE)
  [07:07:09.802]     }
  [07:07:09.802]     ...future.frame <- base::sys.nframe()
  [07:07:09.802]     ...future.conditions <- base::list()
  [07:07:09.802]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.802]     ...future.result <- base::tryCatch({
  [07:07:09.802]         base::withCallingHandlers({
  [07:07:09.802]             ...future.value <- base::withVisible(base::local({
  [07:07:09.802]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.802]             }))
  [07:07:09.802]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.802]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.802]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.802]                 version = "1.8")
  [07:07:09.802]         }, condition = base::local({
  [07:07:09.802]             c <- base::c
  [07:07:09.802]             inherits <- base::inherits
  [07:07:09.802]             invokeRestart <- base::invokeRestart
  [07:07:09.802]             length <- base::length
  [07:07:09.802]             list <- base::list
  [07:07:09.802]             seq.int <- base::seq.int
  [07:07:09.802]             signalCondition <- base::signalCondition
  [07:07:09.802]             sys.calls <- base::sys.calls
  [07:07:09.802]             Sys.time <- base::Sys.time
  [07:07:09.802]             `[[` <- base::`[[`
  [07:07:09.802]             `+` <- base::`+`
  [07:07:09.802]             `<<-` <- base::`<<-`
  [07:07:09.802]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.802]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.802]                   3L)]
  [07:07:09.802]             }
  [07:07:09.802]             function(cond) {
  [07:07:09.802]                 if (inherits(cond, "error")) {
  [07:07:09.802]                   sessionInformation <- function() {
  [07:07:09.802]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.802]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.802]                       search = base::search(), system = base::Sys.info())
  [07:07:09.802]                   }
  [07:07:09.802]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.802]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.802]                     cond$call), session = sessionInformation(), 
  [07:07:09.802]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.802]                   signalCondition(cond)
  [07:07:09.802]                 }
  [07:07:09.802]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.802]                 ))) {
  [07:07:09.802]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.802]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.802]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.802]                   if (!signal) {
  [07:07:09.802]                     muffleCondition <- function (cond) 
  [07:07:09.802]                     {
  [07:07:09.802]                       inherits <- base::inherits
  [07:07:09.802]                       invokeRestart <- base::invokeRestart
  [07:07:09.802]                       muffled <- FALSE
  [07:07:09.802]                       if (inherits(cond, "message")) {
  [07:07:09.802]                         invokeRestart("muffleMessage")
  [07:07:09.802]                         muffled <- TRUE
  [07:07:09.802]                       }
  [07:07:09.802]                       else if (inherits(cond, "warning")) {
  [07:07:09.802]                         invokeRestart("muffleWarning")
  [07:07:09.802]                         muffled <- TRUE
  [07:07:09.802]                       }
  [07:07:09.802]                       else if (inherits(cond, "condition")) {
  [07:07:09.802]                         computeRestarts <- base::computeRestarts
  [07:07:09.802]                         grepl <- base::grepl
  [07:07:09.802]                         is.null <- base::is.null
  [07:07:09.802]                         restarts <- computeRestarts(cond)
  [07:07:09.802]                         for (restart in restarts) {
  [07:07:09.802]                           name <- restart$name
  [07:07:09.802]                           if (is.null(name)) 
  [07:07:09.802]                             next
  [07:07:09.802]                           if (!grepl("^muffle", name)) 
  [07:07:09.802]                             next
  [07:07:09.802]                           invokeRestart(restart)
  [07:07:09.802]                           muffled <- TRUE
  [07:07:09.802]                           break
  [07:07:09.802]                         }
  [07:07:09.802]                       }
  [07:07:09.802]                       invisible(muffled)
  [07:07:09.802]                     }
  [07:07:09.802]                     muffleCondition(cond)
  [07:07:09.802]                   }
  [07:07:09.802]                 }
  [07:07:09.802]             }
  [07:07:09.802]         }))
  [07:07:09.802]     }, error = function(ex) {
  [07:07:09.802]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.802]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.802]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.802]     }, finally = {
  [07:07:09.802]         {
  [07:07:09.802]             NULL
  [07:07:09.802]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.802]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.802]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.802]                 label = NULL, ...) 
  [07:07:09.802]             {
  [07:07:09.802]                 if (substitute) 
  [07:07:09.802]                   expr <- substitute(expr)
  [07:07:09.802]                 local <- as.logical(local)
  [07:07:09.802]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.802]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.802]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.802]                   label = label, ...)
  [07:07:09.802]                 if (!future$lazy) 
  [07:07:09.802]                   future <- run(future)
  [07:07:09.802]                 invisible(future)
  [07:07:09.802]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.802]         }
  [07:07:09.802]         base::options(...future.oldOptions)
  [07:07:09.802]     })
  [07:07:09.802]     Sys.time
  [07:07:09.802]     if (base::is.na(NA)) {
  [07:07:09.802]     }
  [07:07:09.802]     else {
  [07:07:09.802]         base::sink(type = "output", split = FALSE)
  [07:07:09.802]         if (NA) {
  [07:07:09.802]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.802]         }
  [07:07:09.802]         else {
  [07:07:09.802]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.802]         }
  [07:07:09.802]         base::close(...future.stdout)
  [07:07:09.802]         ...future.stdout <- NULL
  [07:07:09.802]     }
  [07:07:09.802]     ...future.result$conditions <- ...future.conditions
  [07:07:09.802]     ...future.result
  [07:07:09.802] }
  [07:07:09.811] plan(): Setting new future strategy stack:
  [07:07:09.813] List of future strategies:
  [07:07:09.813] 1. sequential:
  [07:07:09.813]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.813]    - tweaked: FALSE
  [07:07:09.813]    - call: NULL
  [07:07:09.816] plan(): nbrOfWorkers() = 1
  [07:07:09.819] plan(): Setting new future strategy stack:
  [07:07:09.821] List of future strategies:
  [07:07:09.821] 1. sequential:
  [07:07:09.821]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.821]    - tweaked: FALSE
  [07:07:09.821]    - call: NULL
  [07:07:09.824] plan(): nbrOfWorkers() = 1
  [07:07:09.826] SequentialFuture started (and completed)
  [07:07:09.829] plan(): Setting new future strategy stack:
  [07:07:09.831] List of future strategies:
  [07:07:09.831] 1. sequential:
  [07:07:09.831]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.831]    - tweaked: FALSE
  [07:07:09.831]    - call: NULL
  [07:07:09.833] plan(): nbrOfWorkers() = 1
  [07:07:09.835] SequentialFuture started (and completed)
  [07:07:09.840] Packages needed by the future expression (n = 0): <none>
  [07:07:09.842] Packages needed by future strategies (n = 0): <none>
  [07:07:09.851] {
  [07:07:09.851]     {
  [07:07:09.851]         ...future.startTime <- base::Sys.time()
  [07:07:09.851]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.851]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.851]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.851]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.851]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.851]         {
  [07:07:09.851]             {
  [07:07:09.851]                 base::local({
  [07:07:09.851]                   has_future <- base::requireNamespace("future", 
  [07:07:09.851]                     quietly = TRUE)
  [07:07:09.851]                   version <- if (has_future) 
  [07:07:09.851]                     utils::packageVersion("future")
  [07:07:09.851]                   else NULL
  [07:07:09.851]                   if (!has_future || version < "1.8.0") {
  [07:07:09.851]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.851]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.851]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.851]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.851]                         "release", "version")], collapse = " "), 
  [07:07:09.851]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.851]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.851]                       info)
  [07:07:09.851]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.851]                     if (!has_future) {
  [07:07:09.851]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.851]                         info)
  [07:07:09.851]                     }
  [07:07:09.851]                     else {
  [07:07:09.851]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.851]                         info, version)
  [07:07:09.851]                     }
  [07:07:09.851]                     base::stop(msg)
  [07:07:09.851]                   }
  [07:07:09.851]                 })
  [07:07:09.851]             }
  [07:07:09.851]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.851]         }
  [07:07:09.851]     }
  [07:07:09.851]     if (base::is.na(NA)) {
  [07:07:09.851]     }
  [07:07:09.851]     else {
  [07:07:09.851]         if (NA) {
  [07:07:09.851]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.851]                 open = "w")
  [07:07:09.851]         }
  [07:07:09.851]         else {
  [07:07:09.851]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.851]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.851]         }
  [07:07:09.851]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.851]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.851]             base::sink(type = "output", split = FALSE)
  [07:07:09.851]             base::close(...future.stdout)
  [07:07:09.851]         }, add = TRUE)
  [07:07:09.851]     }
  [07:07:09.851]     ...future.frame <- base::sys.nframe()
  [07:07:09.851]     ...future.conditions <- base::list()
  [07:07:09.851]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.851]     ...future.result <- base::tryCatch({
  [07:07:09.851]         base::withCallingHandlers({
  [07:07:09.851]             ...future.value <- base::withVisible(base::local({
  [07:07:09.851]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.851]             }))
  [07:07:09.851]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.851]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.851]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.851]                 version = "1.8")
  [07:07:09.851]         }, condition = base::local({
  [07:07:09.851]             c <- base::c
  [07:07:09.851]             inherits <- base::inherits
  [07:07:09.851]             invokeRestart <- base::invokeRestart
  [07:07:09.851]             length <- base::length
  [07:07:09.851]             list <- base::list
  [07:07:09.851]             seq.int <- base::seq.int
  [07:07:09.851]             signalCondition <- base::signalCondition
  [07:07:09.851]             sys.calls <- base::sys.calls
  [07:07:09.851]             Sys.time <- base::Sys.time
  [07:07:09.851]             `[[` <- base::`[[`
  [07:07:09.851]             `+` <- base::`+`
  [07:07:09.851]             `<<-` <- base::`<<-`
  [07:07:09.851]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.851]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.851]                   3L)]
  [07:07:09.851]             }
  [07:07:09.851]             function(cond) {
  [07:07:09.851]                 if (inherits(cond, "error")) {
  [07:07:09.851]                   sessionInformation <- function() {
  [07:07:09.851]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.851]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.851]                       search = base::search(), system = base::Sys.info())
  [07:07:09.851]                   }
  [07:07:09.851]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.851]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.851]                     cond$call), session = sessionInformation(), 
  [07:07:09.851]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.851]                   signalCondition(cond)
  [07:07:09.851]                 }
  [07:07:09.851]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.851]                 ))) {
  [07:07:09.851]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.851]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.851]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.851]                   if (!signal) {
  [07:07:09.851]                     muffleCondition <- function (cond) 
  [07:07:09.851]                     {
  [07:07:09.851]                       inherits <- base::inherits
  [07:07:09.851]                       invokeRestart <- base::invokeRestart
  [07:07:09.851]                       muffled <- FALSE
  [07:07:09.851]                       if (inherits(cond, "message")) {
  [07:07:09.851]                         invokeRestart("muffleMessage")
  [07:07:09.851]                         muffled <- TRUE
  [07:07:09.851]                       }
  [07:07:09.851]                       else if (inherits(cond, "warning")) {
  [07:07:09.851]                         invokeRestart("muffleWarning")
  [07:07:09.851]                         muffled <- TRUE
  [07:07:09.851]                       }
  [07:07:09.851]                       else if (inherits(cond, "condition")) {
  [07:07:09.851]                         computeRestarts <- base::computeRestarts
  [07:07:09.851]                         grepl <- base::grepl
  [07:07:09.851]                         is.null <- base::is.null
  [07:07:09.851]                         restarts <- computeRestarts(cond)
  [07:07:09.851]                         for (restart in restarts) {
  [07:07:09.851]                           name <- restart$name
  [07:07:09.851]                           if (is.null(name)) 
  [07:07:09.851]                             next
  [07:07:09.851]                           if (!grepl("^muffle", name)) 
  [07:07:09.851]                             next
  [07:07:09.851]                           invokeRestart(restart)
  [07:07:09.851]                           muffled <- TRUE
  [07:07:09.851]                           break
  [07:07:09.851]                         }
  [07:07:09.851]                       }
  [07:07:09.851]                       invisible(muffled)
  [07:07:09.851]                     }
  [07:07:09.851]                     muffleCondition(cond)
  [07:07:09.851]                   }
  [07:07:09.851]                 }
  [07:07:09.851]             }
  [07:07:09.851]         }))
  [07:07:09.851]     }, error = function(ex) {
  [07:07:09.851]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.851]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.851]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.851]     }, finally = {
  [07:07:09.851]         {
  [07:07:09.851]             NULL
  [07:07:09.851]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.851]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.851]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.851]                 label = NULL, ...) 
  [07:07:09.851]             {
  [07:07:09.851]                 if (substitute) 
  [07:07:09.851]                   expr <- substitute(expr)
  [07:07:09.851]                 local <- as.logical(local)
  [07:07:09.851]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.851]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.851]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.851]                   label = label, ...)
  [07:07:09.851]                 if (!future$lazy) 
  [07:07:09.851]                   future <- run(future)
  [07:07:09.851]                 invisible(future)
  [07:07:09.851]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.851]         }
  [07:07:09.851]         base::options(...future.oldOptions)
  [07:07:09.851]     })
  [07:07:09.851]     Sys.time
  [07:07:09.851]     if (base::is.na(NA)) {
  [07:07:09.851]     }
  [07:07:09.851]     else {
  [07:07:09.851]         base::sink(type = "output", split = FALSE)
  [07:07:09.851]         if (NA) {
  [07:07:09.851]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.851]         }
  [07:07:09.851]         else {
  [07:07:09.851]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.851]         }
  [07:07:09.851]         base::close(...future.stdout)
  [07:07:09.851]         ...future.stdout <- NULL
  [07:07:09.851]     }
  [07:07:09.851]     ...future.result$conditions <- ...future.conditions
  [07:07:09.851]     ...future.result
  [07:07:09.851] }
  [07:07:09.861] plan(): Setting new future strategy stack:
  [07:07:09.863] List of future strategies:
  [07:07:09.863] 1. sequential:
  [07:07:09.863]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.863]    - tweaked: FALSE
  [07:07:09.863]    - call: NULL
  [07:07:09.866] plan(): nbrOfWorkers() = 1
  [07:07:09.869] plan(): Setting new future strategy stack:
  [07:07:09.871] List of future strategies:
  [07:07:09.871] 1. sequential:
  [07:07:09.871]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.871]    - tweaked: FALSE
  [07:07:09.871]    - call: NULL
  [07:07:09.874] plan(): nbrOfWorkers() = 1
  [07:07:09.876] SequentialFuture started (and completed)
  [07:07:09.879] plan(): Setting new future strategy stack:
  [07:07:09.880] List of future strategies:
  [07:07:09.880] 1. sequential:
  [07:07:09.880]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.880]    - tweaked: FALSE
  [07:07:09.880]    - call: NULL
  [07:07:09.884] plan(): nbrOfWorkers() = 1
  [07:07:09.886] SequentialFuture started (and completed)
  [07:07:09.890] Packages needed by the future expression (n = 0): <none>
  [07:07:09.891] Packages needed by future strategies (n = 0): <none>
  [07:07:09.901] {
  [07:07:09.901]     {
  [07:07:09.901]         ...future.startTime <- base::Sys.time()
  [07:07:09.901]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.901]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.901]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.901]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.901]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.901]         {
  [07:07:09.901]             {
  [07:07:09.901]                 base::local({
  [07:07:09.901]                   has_future <- base::requireNamespace("future", 
  [07:07:09.901]                     quietly = TRUE)
  [07:07:09.901]                   version <- if (has_future) 
  [07:07:09.901]                     utils::packageVersion("future")
  [07:07:09.901]                   else NULL
  [07:07:09.901]                   if (!has_future || version < "1.8.0") {
  [07:07:09.901]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.901]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.901]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.901]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.901]                         "release", "version")], collapse = " "), 
  [07:07:09.901]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.901]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.901]                       info)
  [07:07:09.901]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.901]                     if (!has_future) {
  [07:07:09.901]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.901]                         info)
  [07:07:09.901]                     }
  [07:07:09.901]                     else {
  [07:07:09.901]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.901]                         info, version)
  [07:07:09.901]                     }
  [07:07:09.901]                     base::stop(msg)
  [07:07:09.901]                   }
  [07:07:09.901]                 })
  [07:07:09.901]             }
  [07:07:09.901]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.901]         }
  [07:07:09.901]     }
  [07:07:09.901]     if (base::is.na(NA)) {
  [07:07:09.901]     }
  [07:07:09.901]     else {
  [07:07:09.901]         if (NA) {
  [07:07:09.901]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.901]                 open = "w")
  [07:07:09.901]         }
  [07:07:09.901]         else {
  [07:07:09.901]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.901]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.901]         }
  [07:07:09.901]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.901]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.901]             base::sink(type = "output", split = FALSE)
  [07:07:09.901]             base::close(...future.stdout)
  [07:07:09.901]         }, add = TRUE)
  [07:07:09.901]     }
  [07:07:09.901]     ...future.frame <- base::sys.nframe()
  [07:07:09.901]     ...future.conditions <- base::list()
  [07:07:09.901]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.901]     ...future.result <- base::tryCatch({
  [07:07:09.901]         base::withCallingHandlers({
  [07:07:09.901]             ...future.value <- base::withVisible(base::local({
  [07:07:09.901]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.901]             }))
  [07:07:09.901]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.901]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.901]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.901]                 version = "1.8")
  [07:07:09.901]         }, condition = base::local({
  [07:07:09.901]             c <- base::c
  [07:07:09.901]             inherits <- base::inherits
  [07:07:09.901]             invokeRestart <- base::invokeRestart
  [07:07:09.901]             length <- base::length
  [07:07:09.901]             list <- base::list
  [07:07:09.901]             seq.int <- base::seq.int
  [07:07:09.901]             signalCondition <- base::signalCondition
  [07:07:09.901]             sys.calls <- base::sys.calls
  [07:07:09.901]             Sys.time <- base::Sys.time
  [07:07:09.901]             `[[` <- base::`[[`
  [07:07:09.901]             `+` <- base::`+`
  [07:07:09.901]             `<<-` <- base::`<<-`
  [07:07:09.901]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.901]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.901]                   3L)]
  [07:07:09.901]             }
  [07:07:09.901]             function(cond) {
  [07:07:09.901]                 if (inherits(cond, "error")) {
  [07:07:09.901]                   sessionInformation <- function() {
  [07:07:09.901]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.901]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.901]                       search = base::search(), system = base::Sys.info())
  [07:07:09.901]                   }
  [07:07:09.901]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.901]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.901]                     cond$call), session = sessionInformation(), 
  [07:07:09.901]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.901]                   signalCondition(cond)
  [07:07:09.901]                 }
  [07:07:09.901]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.901]                 ))) {
  [07:07:09.901]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.901]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.901]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.901]                   if (!signal) {
  [07:07:09.901]                     muffleCondition <- function (cond) 
  [07:07:09.901]                     {
  [07:07:09.901]                       inherits <- base::inherits
  [07:07:09.901]                       invokeRestart <- base::invokeRestart
  [07:07:09.901]                       muffled <- FALSE
  [07:07:09.901]                       if (inherits(cond, "message")) {
  [07:07:09.901]                         invokeRestart("muffleMessage")
  [07:07:09.901]                         muffled <- TRUE
  [07:07:09.901]                       }
  [07:07:09.901]                       else if (inherits(cond, "warning")) {
  [07:07:09.901]                         invokeRestart("muffleWarning")
  [07:07:09.901]                         muffled <- TRUE
  [07:07:09.901]                       }
  [07:07:09.901]                       else if (inherits(cond, "condition")) {
  [07:07:09.901]                         computeRestarts <- base::computeRestarts
  [07:07:09.901]                         grepl <- base::grepl
  [07:07:09.901]                         is.null <- base::is.null
  [07:07:09.901]                         restarts <- computeRestarts(cond)
  [07:07:09.901]                         for (restart in restarts) {
  [07:07:09.901]                           name <- restart$name
  [07:07:09.901]                           if (is.null(name)) 
  [07:07:09.901]                             next
  [07:07:09.901]                           if (!grepl("^muffle", name)) 
  [07:07:09.901]                             next
  [07:07:09.901]                           invokeRestart(restart)
  [07:07:09.901]                           muffled <- TRUE
  [07:07:09.901]                           break
  [07:07:09.901]                         }
  [07:07:09.901]                       }
  [07:07:09.901]                       invisible(muffled)
  [07:07:09.901]                     }
  [07:07:09.901]                     muffleCondition(cond)
  [07:07:09.901]                   }
  [07:07:09.901]                 }
  [07:07:09.901]             }
  [07:07:09.901]         }))
  [07:07:09.901]     }, error = function(ex) {
  [07:07:09.901]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.901]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.901]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.901]     }, finally = {
  [07:07:09.901]         {
  [07:07:09.901]             NULL
  [07:07:09.901]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.901]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.901]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.901]                 label = NULL, ...) 
  [07:07:09.901]             {
  [07:07:09.901]                 if (substitute) 
  [07:07:09.901]                   expr <- substitute(expr)
  [07:07:09.901]                 local <- as.logical(local)
  [07:07:09.901]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.901]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.901]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.901]                   label = label, ...)
  [07:07:09.901]                 if (!future$lazy) 
  [07:07:09.901]                   future <- run(future)
  [07:07:09.901]                 invisible(future)
  [07:07:09.901]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.901]         }
  [07:07:09.901]         base::options(...future.oldOptions)
  [07:07:09.901]     })
  [07:07:09.901]     Sys.time
  [07:07:09.901]     if (base::is.na(NA)) {
  [07:07:09.901]     }
  [07:07:09.901]     else {
  [07:07:09.901]         base::sink(type = "output", split = FALSE)
  [07:07:09.901]         if (NA) {
  [07:07:09.901]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.901]         }
  [07:07:09.901]         else {
  [07:07:09.901]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.901]         }
  [07:07:09.901]         base::close(...future.stdout)
  [07:07:09.901]         ...future.stdout <- NULL
  [07:07:09.901]     }
  [07:07:09.901]     ...future.result$conditions <- ...future.conditions
  [07:07:09.901]     ...future.result
  [07:07:09.901] }
  [07:07:09.919] plan(): Setting new future strategy stack:
  [07:07:09.921] List of future strategies:
  [07:07:09.921] 1. sequential:
  [07:07:09.921]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.921]    - tweaked: FALSE
  [07:07:09.921]    - call: NULL
  [07:07:09.923] plan(): nbrOfWorkers() = 1
  [07:07:09.926] plan(): Setting new future strategy stack:
  [07:07:09.928] List of future strategies:
  [07:07:09.928] 1. sequential:
  [07:07:09.928]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.928]    - tweaked: FALSE
  [07:07:09.928]    - call: NULL
  [07:07:09.931] plan(): nbrOfWorkers() = 1
  [07:07:09.932] SequentialFuture started (and completed)
  [07:07:09.935] plan(): Setting new future strategy stack:
  [07:07:09.936] List of future strategies:
  [07:07:09.936] 1. sequential:
  [07:07:09.936]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.936]    - tweaked: FALSE
  [07:07:09.936]    - call: NULL
  [07:07:09.939] plan(): nbrOfWorkers() = 1
  [07:07:09.940] SequentialFuture started (and completed)
  [07:07:09.944] Packages needed by the future expression (n = 0): <none>
  [07:07:09.946] Packages needed by future strategies (n = 0): <none>
  [07:07:09.955] {
  [07:07:09.955]     {
  [07:07:09.955]         ...future.startTime <- base::Sys.time()
  [07:07:09.955]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.955]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.955]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.955]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.955]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.955]         {
  [07:07:09.955]             {
  [07:07:09.955]                 base::local({
  [07:07:09.955]                   has_future <- base::requireNamespace("future", 
  [07:07:09.955]                     quietly = TRUE)
  [07:07:09.955]                   version <- if (has_future) 
  [07:07:09.955]                     utils::packageVersion("future")
  [07:07:09.955]                   else NULL
  [07:07:09.955]                   if (!has_future || version < "1.8.0") {
  [07:07:09.955]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.955]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.955]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.955]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.955]                         "release", "version")], collapse = " "), 
  [07:07:09.955]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.955]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.955]                       info)
  [07:07:09.955]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.955]                     if (!has_future) {
  [07:07:09.955]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.955]                         info)
  [07:07:09.955]                     }
  [07:07:09.955]                     else {
  [07:07:09.955]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.955]                         info, version)
  [07:07:09.955]                     }
  [07:07:09.955]                     base::stop(msg)
  [07:07:09.955]                   }
  [07:07:09.955]                 })
  [07:07:09.955]             }
  [07:07:09.955]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.955]         }
  [07:07:09.955]     }
  [07:07:09.955]     if (base::is.na(NA)) {
  [07:07:09.955]     }
  [07:07:09.955]     else {
  [07:07:09.955]         if (NA) {
  [07:07:09.955]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.955]                 open = "w")
  [07:07:09.955]         }
  [07:07:09.955]         else {
  [07:07:09.955]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.955]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.955]         }
  [07:07:09.955]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.955]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.955]             base::sink(type = "output", split = FALSE)
  [07:07:09.955]             base::close(...future.stdout)
  [07:07:09.955]         }, add = TRUE)
  [07:07:09.955]     }
  [07:07:09.955]     ...future.frame <- base::sys.nframe()
  [07:07:09.955]     ...future.conditions <- base::list()
  [07:07:09.955]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.955]     ...future.result <- base::tryCatch({
  [07:07:09.955]         base::withCallingHandlers({
  [07:07:09.955]             ...future.value <- base::withVisible(base::local({
  [07:07:09.955]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.955]             }))
  [07:07:09.955]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.955]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.955]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.955]                 version = "1.8")
  [07:07:09.955]         }, condition = base::local({
  [07:07:09.955]             c <- base::c
  [07:07:09.955]             inherits <- base::inherits
  [07:07:09.955]             invokeRestart <- base::invokeRestart
  [07:07:09.955]             length <- base::length
  [07:07:09.955]             list <- base::list
  [07:07:09.955]             seq.int <- base::seq.int
  [07:07:09.955]             signalCondition <- base::signalCondition
  [07:07:09.955]             sys.calls <- base::sys.calls
  [07:07:09.955]             Sys.time <- base::Sys.time
  [07:07:09.955]             `[[` <- base::`[[`
  [07:07:09.955]             `+` <- base::`+`
  [07:07:09.955]             `<<-` <- base::`<<-`
  [07:07:09.955]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.955]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.955]                   3L)]
  [07:07:09.955]             }
  [07:07:09.955]             function(cond) {
  [07:07:09.955]                 if (inherits(cond, "error")) {
  [07:07:09.955]                   sessionInformation <- function() {
  [07:07:09.955]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.955]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.955]                       search = base::search(), system = base::Sys.info())
  [07:07:09.955]                   }
  [07:07:09.955]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.955]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.955]                     cond$call), session = sessionInformation(), 
  [07:07:09.955]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.955]                   signalCondition(cond)
  [07:07:09.955]                 }
  [07:07:09.955]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.955]                 ))) {
  [07:07:09.955]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.955]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.955]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.955]                   if (!signal) {
  [07:07:09.955]                     muffleCondition <- function (cond) 
  [07:07:09.955]                     {
  [07:07:09.955]                       inherits <- base::inherits
  [07:07:09.955]                       invokeRestart <- base::invokeRestart
  [07:07:09.955]                       muffled <- FALSE
  [07:07:09.955]                       if (inherits(cond, "message")) {
  [07:07:09.955]                         invokeRestart("muffleMessage")
  [07:07:09.955]                         muffled <- TRUE
  [07:07:09.955]                       }
  [07:07:09.955]                       else if (inherits(cond, "warning")) {
  [07:07:09.955]                         invokeRestart("muffleWarning")
  [07:07:09.955]                         muffled <- TRUE
  [07:07:09.955]                       }
  [07:07:09.955]                       else if (inherits(cond, "condition")) {
  [07:07:09.955]                         computeRestarts <- base::computeRestarts
  [07:07:09.955]                         grepl <- base::grepl
  [07:07:09.955]                         is.null <- base::is.null
  [07:07:09.955]                         restarts <- computeRestarts(cond)
  [07:07:09.955]                         for (restart in restarts) {
  [07:07:09.955]                           name <- restart$name
  [07:07:09.955]                           if (is.null(name)) 
  [07:07:09.955]                             next
  [07:07:09.955]                           if (!grepl("^muffle", name)) 
  [07:07:09.955]                             next
  [07:07:09.955]                           invokeRestart(restart)
  [07:07:09.955]                           muffled <- TRUE
  [07:07:09.955]                           break
  [07:07:09.955]                         }
  [07:07:09.955]                       }
  [07:07:09.955]                       invisible(muffled)
  [07:07:09.955]                     }
  [07:07:09.955]                     muffleCondition(cond)
  [07:07:09.955]                   }
  [07:07:09.955]                 }
  [07:07:09.955]             }
  [07:07:09.955]         }))
  [07:07:09.955]     }, error = function(ex) {
  [07:07:09.955]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.955]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.955]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.955]     }, finally = {
  [07:07:09.955]         {
  [07:07:09.955]             NULL
  [07:07:09.955]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.955]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.955]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.955]                 label = NULL, ...) 
  [07:07:09.955]             {
  [07:07:09.955]                 if (substitute) 
  [07:07:09.955]                   expr <- substitute(expr)
  [07:07:09.955]                 local <- as.logical(local)
  [07:07:09.955]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.955]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.955]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.955]                   label = label, ...)
  [07:07:09.955]                 if (!future$lazy) 
  [07:07:09.955]                   future <- run(future)
  [07:07:09.955]                 invisible(future)
  [07:07:09.955]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.955]         }
  [07:07:09.955]         base::options(...future.oldOptions)
  [07:07:09.955]     })
  [07:07:09.955]     Sys.time
  [07:07:09.955]     if (base::is.na(NA)) {
  [07:07:09.955]     }
  [07:07:09.955]     else {
  [07:07:09.955]         base::sink(type = "output", split = FALSE)
  [07:07:09.955]         if (NA) {
  [07:07:09.955]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.955]         }
  [07:07:09.955]         else {
  [07:07:09.955]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.955]         }
  [07:07:09.955]         base::close(...future.stdout)
  [07:07:09.955]         ...future.stdout <- NULL
  [07:07:09.955]     }
  [07:07:09.955]     ...future.result$conditions <- ...future.conditions
  [07:07:09.955]     ...future.result
  [07:07:09.955] }
  [07:07:09.963] plan(): Setting new future strategy stack:
  [07:07:09.964] List of future strategies:
  [07:07:09.964] 1. sequential:
  [07:07:09.964]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.964]    - tweaked: FALSE
  [07:07:09.964]    - call: NULL
  [07:07:09.967] plan(): nbrOfWorkers() = 1
  [07:07:09.969] plan(): Setting new future strategy stack:
  [07:07:09.970] List of future strategies:
  [07:07:09.970] 1. sequential:
  [07:07:09.970]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.970]    - tweaked: FALSE
  [07:07:09.970]    - call: NULL
  [07:07:09.973] plan(): nbrOfWorkers() = 1
  [07:07:09.974] SequentialFuture started (and completed)
  [07:07:09.977] plan(): Setting new future strategy stack:
  [07:07:09.978] List of future strategies:
  [07:07:09.978] 1. sequential:
  [07:07:09.978]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:09.978]    - tweaked: FALSE
  [07:07:09.978]    - call: NULL
  [07:07:09.981] plan(): nbrOfWorkers() = 1
  [07:07:09.982] SequentialFuture started (and completed)
  [07:07:09.986] Packages needed by the future expression (n = 0): <none>
  [07:07:09.988] Packages needed by future strategies (n = 0): <none>
  [07:07:09.997] {
  [07:07:09.997]     {
  [07:07:09.997]         ...future.startTime <- base::Sys.time()
  [07:07:09.997]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:09.997]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:09.997]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:09.997]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:09.997]             future.resolve.recursive = NULL, width = 80L)
  [07:07:09.997]         {
  [07:07:09.997]             {
  [07:07:09.997]                 base::local({
  [07:07:09.997]                   has_future <- base::requireNamespace("future", 
  [07:07:09.997]                     quietly = TRUE)
  [07:07:09.997]                   version <- if (has_future) 
  [07:07:09.997]                     utils::packageVersion("future")
  [07:07:09.997]                   else NULL
  [07:07:09.997]                   if (!has_future || version < "1.8.0") {
  [07:07:09.997]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:09.997]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:09.997]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:09.997]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:09.997]                         "release", "version")], collapse = " "), 
  [07:07:09.997]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:09.997]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:09.997]                       info)
  [07:07:09.997]                     info <- base::paste(info, collapse = "; ")
  [07:07:09.997]                     if (!has_future) {
  [07:07:09.997]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:09.997]                         info)
  [07:07:09.997]                     }
  [07:07:09.997]                     else {
  [07:07:09.997]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:09.997]                         info, version)
  [07:07:09.997]                     }
  [07:07:09.997]                     base::stop(msg)
  [07:07:09.997]                   }
  [07:07:09.997]                 })
  [07:07:09.997]             }
  [07:07:09.997]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:09.997]         }
  [07:07:09.997]     }
  [07:07:09.997]     if (base::is.na(NA)) {
  [07:07:09.997]     }
  [07:07:09.997]     else {
  [07:07:09.997]         if (NA) {
  [07:07:09.997]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:09.997]                 open = "w")
  [07:07:09.997]         }
  [07:07:09.997]         else {
  [07:07:09.997]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:09.997]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:09.997]         }
  [07:07:09.997]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:09.997]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:09.997]             base::sink(type = "output", split = FALSE)
  [07:07:09.997]             base::close(...future.stdout)
  [07:07:09.997]         }, add = TRUE)
  [07:07:09.997]     }
  [07:07:09.997]     ...future.frame <- base::sys.nframe()
  [07:07:09.997]     ...future.conditions <- base::list()
  [07:07:09.997]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:09.997]     ...future.result <- base::tryCatch({
  [07:07:09.997]         base::withCallingHandlers({
  [07:07:09.997]             ...future.value <- base::withVisible(base::local({
  [07:07:09.997]                 x[[i - 2]] + x[[i - 1]]
  [07:07:09.997]             }))
  [07:07:09.997]             future::FutureResult(value = ...future.value$value, 
  [07:07:09.997]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.997]                   ...future.rng), started = ...future.startTime, 
  [07:07:09.997]                 version = "1.8")
  [07:07:09.997]         }, condition = base::local({
  [07:07:09.997]             c <- base::c
  [07:07:09.997]             inherits <- base::inherits
  [07:07:09.997]             invokeRestart <- base::invokeRestart
  [07:07:09.997]             length <- base::length
  [07:07:09.997]             list <- base::list
  [07:07:09.997]             seq.int <- base::seq.int
  [07:07:09.997]             signalCondition <- base::signalCondition
  [07:07:09.997]             sys.calls <- base::sys.calls
  [07:07:09.997]             Sys.time <- base::Sys.time
  [07:07:09.997]             `[[` <- base::`[[`
  [07:07:09.997]             `+` <- base::`+`
  [07:07:09.997]             `<<-` <- base::`<<-`
  [07:07:09.997]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:09.997]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:09.997]                   3L)]
  [07:07:09.997]             }
  [07:07:09.997]             function(cond) {
  [07:07:09.997]                 if (inherits(cond, "error")) {
  [07:07:09.997]                   sessionInformation <- function() {
  [07:07:09.997]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:09.997]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:09.997]                       search = base::search(), system = base::Sys.info())
  [07:07:09.997]                   }
  [07:07:09.997]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.997]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:09.997]                     cond$call), session = sessionInformation(), 
  [07:07:09.997]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:09.997]                   signalCondition(cond)
  [07:07:09.997]                 }
  [07:07:09.997]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:09.997]                 ))) {
  [07:07:09.997]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:09.997]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:09.997]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:09.997]                   if (!signal) {
  [07:07:09.997]                     muffleCondition <- function (cond) 
  [07:07:09.997]                     {
  [07:07:09.997]                       inherits <- base::inherits
  [07:07:09.997]                       invokeRestart <- base::invokeRestart
  [07:07:09.997]                       muffled <- FALSE
  [07:07:09.997]                       if (inherits(cond, "message")) {
  [07:07:09.997]                         invokeRestart("muffleMessage")
  [07:07:09.997]                         muffled <- TRUE
  [07:07:09.997]                       }
  [07:07:09.997]                       else if (inherits(cond, "warning")) {
  [07:07:09.997]                         invokeRestart("muffleWarning")
  [07:07:09.997]                         muffled <- TRUE
  [07:07:09.997]                       }
  [07:07:09.997]                       else if (inherits(cond, "condition")) {
  [07:07:09.997]                         computeRestarts <- base::computeRestarts
  [07:07:09.997]                         grepl <- base::grepl
  [07:07:09.997]                         is.null <- base::is.null
  [07:07:09.997]                         restarts <- computeRestarts(cond)
  [07:07:09.997]                         for (restart in restarts) {
  [07:07:09.997]                           name <- restart$name
  [07:07:09.997]                           if (is.null(name)) 
  [07:07:09.997]                             next
  [07:07:09.997]                           if (!grepl("^muffle", name)) 
  [07:07:09.997]                             next
  [07:07:09.997]                           invokeRestart(restart)
  [07:07:09.997]                           muffled <- TRUE
  [07:07:09.997]                           break
  [07:07:09.997]                         }
  [07:07:09.997]                       }
  [07:07:09.997]                       invisible(muffled)
  [07:07:09.997]                     }
  [07:07:09.997]                     muffleCondition(cond)
  [07:07:09.997]                   }
  [07:07:09.997]                 }
  [07:07:09.997]             }
  [07:07:09.997]         }))
  [07:07:09.997]     }, error = function(ex) {
  [07:07:09.997]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:09.997]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:09.997]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:09.997]     }, finally = {
  [07:07:09.997]         {
  [07:07:09.997]             NULL
  [07:07:09.997]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:09.997]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:09.997]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:09.997]                 label = NULL, ...) 
  [07:07:09.997]             {
  [07:07:09.997]                 if (substitute) 
  [07:07:09.997]                   expr <- substitute(expr)
  [07:07:09.997]                 local <- as.logical(local)
  [07:07:09.997]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:09.997]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:09.997]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:09.997]                   label = label, ...)
  [07:07:09.997]                 if (!future$lazy) 
  [07:07:09.997]                   future <- run(future)
  [07:07:09.997]                 invisible(future)
  [07:07:09.997]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:09.997]         }
  [07:07:09.997]         base::options(...future.oldOptions)
  [07:07:09.997]     })
  [07:07:09.997]     Sys.time
  [07:07:09.997]     if (base::is.na(NA)) {
  [07:07:09.997]     }
  [07:07:09.997]     else {
  [07:07:09.997]         base::sink(type = "output", split = FALSE)
  [07:07:09.997]         if (NA) {
  [07:07:09.997]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:09.997]         }
  [07:07:09.997]         else {
  [07:07:09.997]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:09.997]         }
  [07:07:09.997]         base::close(...future.stdout)
  [07:07:09.997]         ...future.stdout <- NULL
  [07:07:09.997]     }
  [07:07:09.997]     ...future.result$conditions <- ...future.conditions
  [07:07:09.997]     ...future.result
  [07:07:09.997] }
  [07:07:10.006] plan(): Setting new future strategy stack:
  [07:07:10.007] List of future strategies:
  [07:07:10.007] 1. sequential:
  [07:07:10.007]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.007]    - tweaked: FALSE
  [07:07:10.007]    - call: NULL
  [07:07:10.010] plan(): nbrOfWorkers() = 1
  [07:07:10.012] plan(): Setting new future strategy stack:
  [07:07:10.013] List of future strategies:
  [07:07:10.013] 1. sequential:
  [07:07:10.013]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.013]    - tweaked: FALSE
  [07:07:10.013]    - call: NULL
  [07:07:10.015] plan(): nbrOfWorkers() = 1
  [07:07:10.017] SequentialFuture started (and completed)
  [07:07:10.019] plan(): Setting new future strategy stack:
  [07:07:10.020] List of future strategies:
  [07:07:10.020] 1. sequential:
  [07:07:10.020]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.020]    - tweaked: FALSE
  [07:07:10.020]    - call: NULL
  [07:07:10.022] plan(): nbrOfWorkers() = 1
  [07:07:10.023] SequentialFuture started (and completed)
  [07:07:10.027] Packages needed by the future expression (n = 0): <none>
  [07:07:10.028] Packages needed by future strategies (n = 0): <none>
  [07:07:10.036] {
  [07:07:10.036]     {
  [07:07:10.036]         ...future.startTime <- base::Sys.time()
  [07:07:10.036]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:10.036]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:10.036]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:10.036]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:10.036]             future.resolve.recursive = NULL, width = 80L)
  [07:07:10.036]         {
  [07:07:10.036]             {
  [07:07:10.036]                 base::local({
  [07:07:10.036]                   has_future <- base::requireNamespace("future", 
  [07:07:10.036]                     quietly = TRUE)
  [07:07:10.036]                   version <- if (has_future) 
  [07:07:10.036]                     utils::packageVersion("future")
  [07:07:10.036]                   else NULL
  [07:07:10.036]                   if (!has_future || version < "1.8.0") {
  [07:07:10.036]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:10.036]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:10.036]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:10.036]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:10.036]                         "release", "version")], collapse = " "), 
  [07:07:10.036]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:10.036]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:10.036]                       info)
  [07:07:10.036]                     info <- base::paste(info, collapse = "; ")
  [07:07:10.036]                     if (!has_future) {
  [07:07:10.036]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:10.036]                         info)
  [07:07:10.036]                     }
  [07:07:10.036]                     else {
  [07:07:10.036]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:10.036]                         info, version)
  [07:07:10.036]                     }
  [07:07:10.036]                     base::stop(msg)
  [07:07:10.036]                   }
  [07:07:10.036]                 })
  [07:07:10.036]             }
  [07:07:10.036]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:10.036]         }
  [07:07:10.036]     }
  [07:07:10.036]     if (base::is.na(NA)) {
  [07:07:10.036]     }
  [07:07:10.036]     else {
  [07:07:10.036]         if (NA) {
  [07:07:10.036]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:10.036]                 open = "w")
  [07:07:10.036]         }
  [07:07:10.036]         else {
  [07:07:10.036]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:10.036]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:10.036]         }
  [07:07:10.036]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:10.036]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:10.036]             base::sink(type = "output", split = FALSE)
  [07:07:10.036]             base::close(...future.stdout)
  [07:07:10.036]         }, add = TRUE)
  [07:07:10.036]     }
  [07:07:10.036]     ...future.frame <- base::sys.nframe()
  [07:07:10.036]     ...future.conditions <- base::list()
  [07:07:10.036]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:10.036]     ...future.result <- base::tryCatch({
  [07:07:10.036]         base::withCallingHandlers({
  [07:07:10.036]             ...future.value <- base::withVisible(base::local({
  [07:07:10.036]                 x[[i - 2]] + x[[i - 1]]
  [07:07:10.036]             }))
  [07:07:10.036]             future::FutureResult(value = ...future.value$value, 
  [07:07:10.036]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.036]                   ...future.rng), started = ...future.startTime, 
  [07:07:10.036]                 version = "1.8")
  [07:07:10.036]         }, condition = base::local({
  [07:07:10.036]             c <- base::c
  [07:07:10.036]             inherits <- base::inherits
  [07:07:10.036]             invokeRestart <- base::invokeRestart
  [07:07:10.036]             length <- base::length
  [07:07:10.036]             list <- base::list
  [07:07:10.036]             seq.int <- base::seq.int
  [07:07:10.036]             signalCondition <- base::signalCondition
  [07:07:10.036]             sys.calls <- base::sys.calls
  [07:07:10.036]             Sys.time <- base::Sys.time
  [07:07:10.036]             `[[` <- base::`[[`
  [07:07:10.036]             `+` <- base::`+`
  [07:07:10.036]             `<<-` <- base::`<<-`
  [07:07:10.036]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:10.036]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:10.036]                   3L)]
  [07:07:10.036]             }
  [07:07:10.036]             function(cond) {
  [07:07:10.036]                 if (inherits(cond, "error")) {
  [07:07:10.036]                   sessionInformation <- function() {
  [07:07:10.036]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:10.036]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:10.036]                       search = base::search(), system = base::Sys.info())
  [07:07:10.036]                   }
  [07:07:10.036]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.036]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:10.036]                     cond$call), session = sessionInformation(), 
  [07:07:10.036]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:10.036]                   signalCondition(cond)
  [07:07:10.036]                 }
  [07:07:10.036]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:10.036]                 ))) {
  [07:07:10.036]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:10.036]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.036]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:10.036]                   if (!signal) {
  [07:07:10.036]                     muffleCondition <- function (cond) 
  [07:07:10.036]                     {
  [07:07:10.036]                       inherits <- base::inherits
  [07:07:10.036]                       invokeRestart <- base::invokeRestart
  [07:07:10.036]                       muffled <- FALSE
  [07:07:10.036]                       if (inherits(cond, "message")) {
  [07:07:10.036]                         invokeRestart("muffleMessage")
  [07:07:10.036]                         muffled <- TRUE
  [07:07:10.036]                       }
  [07:07:10.036]                       else if (inherits(cond, "warning")) {
  [07:07:10.036]                         invokeRestart("muffleWarning")
  [07:07:10.036]                         muffled <- TRUE
  [07:07:10.036]                       }
  [07:07:10.036]                       else if (inherits(cond, "condition")) {
  [07:07:10.036]                         computeRestarts <- base::computeRestarts
  [07:07:10.036]                         grepl <- base::grepl
  [07:07:10.036]                         is.null <- base::is.null
  [07:07:10.036]                         restarts <- computeRestarts(cond)
  [07:07:10.036]                         for (restart in restarts) {
  [07:07:10.036]                           name <- restart$name
  [07:07:10.036]                           if (is.null(name)) 
  [07:07:10.036]                             next
  [07:07:10.036]                           if (!grepl("^muffle", name)) 
  [07:07:10.036]                             next
  [07:07:10.036]                           invokeRestart(restart)
  [07:07:10.036]                           muffled <- TRUE
  [07:07:10.036]                           break
  [07:07:10.036]                         }
  [07:07:10.036]                       }
  [07:07:10.036]                       invisible(muffled)
  [07:07:10.036]                     }
  [07:07:10.036]                     muffleCondition(cond)
  [07:07:10.036]                   }
  [07:07:10.036]                 }
  [07:07:10.036]             }
  [07:07:10.036]         }))
  [07:07:10.036]     }, error = function(ex) {
  [07:07:10.036]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:10.036]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.036]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:10.036]     }, finally = {
  [07:07:10.036]         {
  [07:07:10.036]             NULL
  [07:07:10.036]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:10.036]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:10.036]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:10.036]                 label = NULL, ...) 
  [07:07:10.036]             {
  [07:07:10.036]                 if (substitute) 
  [07:07:10.036]                   expr <- substitute(expr)
  [07:07:10.036]                 local <- as.logical(local)
  [07:07:10.036]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:10.036]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:10.036]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:10.036]                   label = label, ...)
  [07:07:10.036]                 if (!future$lazy) 
  [07:07:10.036]                   future <- run(future)
  [07:07:10.036]                 invisible(future)
  [07:07:10.036]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:10.036]         }
  [07:07:10.036]         base::options(...future.oldOptions)
  [07:07:10.036]     })
  [07:07:10.036]     Sys.time
  [07:07:10.036]     if (base::is.na(NA)) {
  [07:07:10.036]     }
  [07:07:10.036]     else {
  [07:07:10.036]         base::sink(type = "output", split = FALSE)
  [07:07:10.036]         if (NA) {
  [07:07:10.036]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:10.036]         }
  [07:07:10.036]         else {
  [07:07:10.036]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:10.036]         }
  [07:07:10.036]         base::close(...future.stdout)
  [07:07:10.036]         ...future.stdout <- NULL
  [07:07:10.036]     }
  [07:07:10.036]     ...future.result$conditions <- ...future.conditions
  [07:07:10.036]     ...future.result
  [07:07:10.036] }
  [07:07:10.043] plan(): Setting new future strategy stack:
  [07:07:10.044] List of future strategies:
  [07:07:10.044] 1. sequential:
  [07:07:10.044]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.044]    - tweaked: FALSE
  [07:07:10.044]    - call: NULL
  [07:07:10.047] plan(): nbrOfWorkers() = 1
  [07:07:10.049] plan(): Setting new future strategy stack:
  [07:07:10.050] List of future strategies:
  [07:07:10.050] 1. sequential:
  [07:07:10.050]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.050]    - tweaked: FALSE
  [07:07:10.050]    - call: NULL
  [07:07:10.052] plan(): nbrOfWorkers() = 1
  [07:07:10.053] SequentialFuture started (and completed)
  [07:07:10.059] plan(): Setting new future strategy stack:
  [07:07:10.060] List of future strategies:
  [07:07:10.060] 1. sequential:
  [07:07:10.060]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.060]    - tweaked: FALSE
  [07:07:10.060]    - call: NULL
  [07:07:10.062] plan(): nbrOfWorkers() = 1
  [07:07:10.063] SequentialFuture started (and completed)
  [07:07:10.067] Packages needed by the future expression (n = 0): <none>
  [07:07:10.068] Packages needed by future strategies (n = 0): <none>
  [07:07:10.076] {
  [07:07:10.076]     {
  [07:07:10.076]         ...future.startTime <- base::Sys.time()
  [07:07:10.076]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:10.076]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:10.076]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:10.076]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:10.076]             future.resolve.recursive = NULL, width = 80L)
  [07:07:10.076]         {
  [07:07:10.076]             {
  [07:07:10.076]                 base::local({
  [07:07:10.076]                   has_future <- base::requireNamespace("future", 
  [07:07:10.076]                     quietly = TRUE)
  [07:07:10.076]                   version <- if (has_future) 
  [07:07:10.076]                     utils::packageVersion("future")
  [07:07:10.076]                   else NULL
  [07:07:10.076]                   if (!has_future || version < "1.8.0") {
  [07:07:10.076]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:10.076]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:10.076]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:10.076]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:10.076]                         "release", "version")], collapse = " "), 
  [07:07:10.076]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:10.076]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:10.076]                       info)
  [07:07:10.076]                     info <- base::paste(info, collapse = "; ")
  [07:07:10.076]                     if (!has_future) {
  [07:07:10.076]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:10.076]                         info)
  [07:07:10.076]                     }
  [07:07:10.076]                     else {
  [07:07:10.076]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:10.076]                         info, version)
  [07:07:10.076]                     }
  [07:07:10.076]                     base::stop(msg)
  [07:07:10.076]                   }
  [07:07:10.076]                 })
  [07:07:10.076]             }
  [07:07:10.076]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:10.076]         }
  [07:07:10.076]     }
  [07:07:10.076]     if (base::is.na(NA)) {
  [07:07:10.076]     }
  [07:07:10.076]     else {
  [07:07:10.076]         if (NA) {
  [07:07:10.076]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:10.076]                 open = "w")
  [07:07:10.076]         }
  [07:07:10.076]         else {
  [07:07:10.076]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:10.076]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:10.076]         }
  [07:07:10.076]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:10.076]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:10.076]             base::sink(type = "output", split = FALSE)
  [07:07:10.076]             base::close(...future.stdout)
  [07:07:10.076]         }, add = TRUE)
  [07:07:10.076]     }
  [07:07:10.076]     ...future.frame <- base::sys.nframe()
  [07:07:10.076]     ...future.conditions <- base::list()
  [07:07:10.076]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:10.076]     ...future.result <- base::tryCatch({
  [07:07:10.076]         base::withCallingHandlers({
  [07:07:10.076]             ...future.value <- base::withVisible(base::local({
  [07:07:10.076]                 x[[i - 2]] + x[[i - 1]]
  [07:07:10.076]             }))
  [07:07:10.076]             future::FutureResult(value = ...future.value$value, 
  [07:07:10.076]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.076]                   ...future.rng), started = ...future.startTime, 
  [07:07:10.076]                 version = "1.8")
  [07:07:10.076]         }, condition = base::local({
  [07:07:10.076]             c <- base::c
  [07:07:10.076]             inherits <- base::inherits
  [07:07:10.076]             invokeRestart <- base::invokeRestart
  [07:07:10.076]             length <- base::length
  [07:07:10.076]             list <- base::list
  [07:07:10.076]             seq.int <- base::seq.int
  [07:07:10.076]             signalCondition <- base::signalCondition
  [07:07:10.076]             sys.calls <- base::sys.calls
  [07:07:10.076]             Sys.time <- base::Sys.time
  [07:07:10.076]             `[[` <- base::`[[`
  [07:07:10.076]             `+` <- base::`+`
  [07:07:10.076]             `<<-` <- base::`<<-`
  [07:07:10.076]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:10.076]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:10.076]                   3L)]
  [07:07:10.076]             }
  [07:07:10.076]             function(cond) {
  [07:07:10.076]                 if (inherits(cond, "error")) {
  [07:07:10.076]                   sessionInformation <- function() {
  [07:07:10.076]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:10.076]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:10.076]                       search = base::search(), system = base::Sys.info())
  [07:07:10.076]                   }
  [07:07:10.076]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.076]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:10.076]                     cond$call), session = sessionInformation(), 
  [07:07:10.076]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:10.076]                   signalCondition(cond)
  [07:07:10.076]                 }
  [07:07:10.076]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:10.076]                 ))) {
  [07:07:10.076]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:10.076]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.076]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:10.076]                   if (!signal) {
  [07:07:10.076]                     muffleCondition <- function (cond) 
  [07:07:10.076]                     {
  [07:07:10.076]                       inherits <- base::inherits
  [07:07:10.076]                       invokeRestart <- base::invokeRestart
  [07:07:10.076]                       muffled <- FALSE
  [07:07:10.076]                       if (inherits(cond, "message")) {
  [07:07:10.076]                         invokeRestart("muffleMessage")
  [07:07:10.076]                         muffled <- TRUE
  [07:07:10.076]                       }
  [07:07:10.076]                       else if (inherits(cond, "warning")) {
  [07:07:10.076]                         invokeRestart("muffleWarning")
  [07:07:10.076]                         muffled <- TRUE
  [07:07:10.076]                       }
  [07:07:10.076]                       else if (inherits(cond, "condition")) {
  [07:07:10.076]                         computeRestarts <- base::computeRestarts
  [07:07:10.076]                         grepl <- base::grepl
  [07:07:10.076]                         is.null <- base::is.null
  [07:07:10.076]                         restarts <- computeRestarts(cond)
  [07:07:10.076]                         for (restart in restarts) {
  [07:07:10.076]                           name <- restart$name
  [07:07:10.076]                           if (is.null(name)) 
  [07:07:10.076]                             next
  [07:07:10.076]                           if (!grepl("^muffle", name)) 
  [07:07:10.076]                             next
  [07:07:10.076]                           invokeRestart(restart)
  [07:07:10.076]                           muffled <- TRUE
  [07:07:10.076]                           break
  [07:07:10.076]                         }
  [07:07:10.076]                       }
  [07:07:10.076]                       invisible(muffled)
  [07:07:10.076]                     }
  [07:07:10.076]                     muffleCondition(cond)
  [07:07:10.076]                   }
  [07:07:10.076]                 }
  [07:07:10.076]             }
  [07:07:10.076]         }))
  [07:07:10.076]     }, error = function(ex) {
  [07:07:10.076]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:10.076]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.076]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:10.076]     }, finally = {
  [07:07:10.076]         {
  [07:07:10.076]             NULL
  [07:07:10.076]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:10.076]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:10.076]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:10.076]                 label = NULL, ...) 
  [07:07:10.076]             {
  [07:07:10.076]                 if (substitute) 
  [07:07:10.076]                   expr <- substitute(expr)
  [07:07:10.076]                 local <- as.logical(local)
  [07:07:10.076]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:10.076]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:10.076]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:10.076]                   label = label, ...)
  [07:07:10.076]                 if (!future$lazy) 
  [07:07:10.076]                   future <- run(future)
  [07:07:10.076]                 invisible(future)
  [07:07:10.076]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:10.076]         }
  [07:07:10.076]         base::options(...future.oldOptions)
  [07:07:10.076]     })
  [07:07:10.076]     Sys.time
  [07:07:10.076]     if (base::is.na(NA)) {
  [07:07:10.076]     }
  [07:07:10.076]     else {
  [07:07:10.076]         base::sink(type = "output", split = FALSE)
  [07:07:10.076]         if (NA) {
  [07:07:10.076]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:10.076]         }
  [07:07:10.076]         else {
  [07:07:10.076]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:10.076]         }
  [07:07:10.076]         base::close(...future.stdout)
  [07:07:10.076]         ...future.stdout <- NULL
  [07:07:10.076]     }
  [07:07:10.076]     ...future.result$conditions <- ...future.conditions
  [07:07:10.076]     ...future.result
  [07:07:10.076] }
  [07:07:10.084] plan(): Setting new future strategy stack:
  [07:07:10.085] List of future strategies:
  [07:07:10.085] 1. sequential:
  [07:07:10.085]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.085]    - tweaked: FALSE
  [07:07:10.085]    - call: NULL
  [07:07:10.087] plan(): nbrOfWorkers() = 1
  [07:07:10.089] plan(): Setting new future strategy stack:
  [07:07:10.090] List of future strategies:
  [07:07:10.090] 1. sequential:
  [07:07:10.090]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.090]    - tweaked: FALSE
  [07:07:10.090]    - call: NULL
  [07:07:10.092] plan(): nbrOfWorkers() = 1
  [07:07:10.093] SequentialFuture started (and completed)
  [07:07:10.094] plan(): Setting new future strategy stack:
  [07:07:10.095] List of future strategies:
  [07:07:10.095] 1. sequential:
  [07:07:10.095]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.095]    - tweaked: FALSE
  [07:07:10.095]    - call: NULL
  [07:07:10.097] plan(): nbrOfWorkers() = 1
  [07:07:10.098] SequentialFuture started (and completed)
  [07:07:10.101] Packages needed by the future expression (n = 0): <none>
  [07:07:10.102] Packages needed by future strategies (n = 0): <none>
  [07:07:10.109] {
  [07:07:10.109]     {
  [07:07:10.109]         ...future.startTime <- base::Sys.time()
  [07:07:10.109]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:10.109]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:10.109]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:10.109]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:10.109]             future.resolve.recursive = NULL, width = 80L)
  [07:07:10.109]         {
  [07:07:10.109]             {
  [07:07:10.109]                 base::local({
  [07:07:10.109]                   has_future <- base::requireNamespace("future", 
  [07:07:10.109]                     quietly = TRUE)
  [07:07:10.109]                   version <- if (has_future) 
  [07:07:10.109]                     utils::packageVersion("future")
  [07:07:10.109]                   else NULL
  [07:07:10.109]                   if (!has_future || version < "1.8.0") {
  [07:07:10.109]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:10.109]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:10.109]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:10.109]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:10.109]                         "release", "version")], collapse = " "), 
  [07:07:10.109]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:10.109]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:10.109]                       info)
  [07:07:10.109]                     info <- base::paste(info, collapse = "; ")
  [07:07:10.109]                     if (!has_future) {
  [07:07:10.109]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:10.109]                         info)
  [07:07:10.109]                     }
  [07:07:10.109]                     else {
  [07:07:10.109]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:10.109]                         info, version)
  [07:07:10.109]                     }
  [07:07:10.109]                     base::stop(msg)
  [07:07:10.109]                   }
  [07:07:10.109]                 })
  [07:07:10.109]             }
  [07:07:10.109]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:10.109]         }
  [07:07:10.109]     }
  [07:07:10.109]     if (base::is.na(NA)) {
  [07:07:10.109]     }
  [07:07:10.109]     else {
  [07:07:10.109]         if (NA) {
  [07:07:10.109]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:10.109]                 open = "w")
  [07:07:10.109]         }
  [07:07:10.109]         else {
  [07:07:10.109]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:10.109]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:10.109]         }
  [07:07:10.109]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:10.109]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:10.109]             base::sink(type = "output", split = FALSE)
  [07:07:10.109]             base::close(...future.stdout)
  [07:07:10.109]         }, add = TRUE)
  [07:07:10.109]     }
  [07:07:10.109]     ...future.frame <- base::sys.nframe()
  [07:07:10.109]     ...future.conditions <- base::list()
  [07:07:10.109]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:10.109]     ...future.result <- base::tryCatch({
  [07:07:10.109]         base::withCallingHandlers({
  [07:07:10.109]             ...future.value <- base::withVisible(base::local({
  [07:07:10.109]                 x[[i - 2]] + x[[i - 1]]
  [07:07:10.109]             }))
  [07:07:10.109]             future::FutureResult(value = ...future.value$value, 
  [07:07:10.109]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.109]                   ...future.rng), started = ...future.startTime, 
  [07:07:10.109]                 version = "1.8")
  [07:07:10.109]         }, condition = base::local({
  [07:07:10.109]             c <- base::c
  [07:07:10.109]             inherits <- base::inherits
  [07:07:10.109]             invokeRestart <- base::invokeRestart
  [07:07:10.109]             length <- base::length
  [07:07:10.109]             list <- base::list
  [07:07:10.109]             seq.int <- base::seq.int
  [07:07:10.109]             signalCondition <- base::signalCondition
  [07:07:10.109]             sys.calls <- base::sys.calls
  [07:07:10.109]             Sys.time <- base::Sys.time
  [07:07:10.109]             `[[` <- base::`[[`
  [07:07:10.109]             `+` <- base::`+`
  [07:07:10.109]             `<<-` <- base::`<<-`
  [07:07:10.109]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:10.109]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:10.109]                   3L)]
  [07:07:10.109]             }
  [07:07:10.109]             function(cond) {
  [07:07:10.109]                 if (inherits(cond, "error")) {
  [07:07:10.109]                   sessionInformation <- function() {
  [07:07:10.109]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:10.109]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:10.109]                       search = base::search(), system = base::Sys.info())
  [07:07:10.109]                   }
  [07:07:10.109]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.109]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:10.109]                     cond$call), session = sessionInformation(), 
  [07:07:10.109]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:10.109]                   signalCondition(cond)
  [07:07:10.109]                 }
  [07:07:10.109]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:10.109]                 ))) {
  [07:07:10.109]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:10.109]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.109]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:10.109]                   if (!signal) {
  [07:07:10.109]                     muffleCondition <- function (cond) 
  [07:07:10.109]                     {
  [07:07:10.109]                       inherits <- base::inherits
  [07:07:10.109]                       invokeRestart <- base::invokeRestart
  [07:07:10.109]                       muffled <- FALSE
  [07:07:10.109]                       if (inherits(cond, "message")) {
  [07:07:10.109]                         invokeRestart("muffleMessage")
  [07:07:10.109]                         muffled <- TRUE
  [07:07:10.109]                       }
  [07:07:10.109]                       else if (inherits(cond, "warning")) {
  [07:07:10.109]                         invokeRestart("muffleWarning")
  [07:07:10.109]                         muffled <- TRUE
  [07:07:10.109]                       }
  [07:07:10.109]                       else if (inherits(cond, "condition")) {
  [07:07:10.109]                         computeRestarts <- base::computeRestarts
  [07:07:10.109]                         grepl <- base::grepl
  [07:07:10.109]                         is.null <- base::is.null
  [07:07:10.109]                         restarts <- computeRestarts(cond)
  [07:07:10.109]                         for (restart in restarts) {
  [07:07:10.109]                           name <- restart$name
  [07:07:10.109]                           if (is.null(name)) 
  [07:07:10.109]                             next
  [07:07:10.109]                           if (!grepl("^muffle", name)) 
  [07:07:10.109]                             next
  [07:07:10.109]                           invokeRestart(restart)
  [07:07:10.109]                           muffled <- TRUE
  [07:07:10.109]                           break
  [07:07:10.109]                         }
  [07:07:10.109]                       }
  [07:07:10.109]                       invisible(muffled)
  [07:07:10.109]                     }
  [07:07:10.109]                     muffleCondition(cond)
  [07:07:10.109]                   }
  [07:07:10.109]                 }
  [07:07:10.109]             }
  [07:07:10.109]         }))
  [07:07:10.109]     }, error = function(ex) {
  [07:07:10.109]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:10.109]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.109]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:10.109]     }, finally = {
  [07:07:10.109]         {
  [07:07:10.109]             NULL
  [07:07:10.109]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:10.109]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:10.109]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:10.109]                 label = NULL, ...) 
  [07:07:10.109]             {
  [07:07:10.109]                 if (substitute) 
  [07:07:10.109]                   expr <- substitute(expr)
  [07:07:10.109]                 local <- as.logical(local)
  [07:07:10.109]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:10.109]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:10.109]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:10.109]                   label = label, ...)
  [07:07:10.109]                 if (!future$lazy) 
  [07:07:10.109]                   future <- run(future)
  [07:07:10.109]                 invisible(future)
  [07:07:10.109]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:10.109]         }
  [07:07:10.109]         base::options(...future.oldOptions)
  [07:07:10.109]     })
  [07:07:10.109]     Sys.time
  [07:07:10.109]     if (base::is.na(NA)) {
  [07:07:10.109]     }
  [07:07:10.109]     else {
  [07:07:10.109]         base::sink(type = "output", split = FALSE)
  [07:07:10.109]         if (NA) {
  [07:07:10.109]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:10.109]         }
  [07:07:10.109]         else {
  [07:07:10.109]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:10.109]         }
  [07:07:10.109]         base::close(...future.stdout)
  [07:07:10.109]         ...future.stdout <- NULL
  [07:07:10.109]     }
  [07:07:10.109]     ...future.result$conditions <- ...future.conditions
  [07:07:10.109]     ...future.result
  [07:07:10.109] }
  [07:07:10.117] plan(): Setting new future strategy stack:
  [07:07:10.118] List of future strategies:
  [07:07:10.118] 1. sequential:
  [07:07:10.118]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.118]    - tweaked: FALSE
  [07:07:10.118]    - call: NULL
  [07:07:10.120] plan(): nbrOfWorkers() = 1
  [07:07:10.122] plan(): Setting new future strategy stack:
  [07:07:10.122] List of future strategies:
  [07:07:10.122] 1. sequential:
  [07:07:10.122]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.122]    - tweaked: FALSE
  [07:07:10.122]    - call: NULL
  [07:07:10.124] plan(): nbrOfWorkers() = 1
  [07:07:10.125] SequentialFuture started (and completed)
  [07:07:10.127] plan(): Setting new future strategy stack:
  [07:07:10.127] List of future strategies:
  [07:07:10.127] 1. sequential:
  [07:07:10.127]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.127]    - tweaked: FALSE
  [07:07:10.127]    - call: NULL
  [07:07:10.129] plan(): nbrOfWorkers() = 1
  [07:07:10.130] SequentialFuture started (and completed)
  [07:07:10.133] Packages needed by the future expression (n = 0): <none>
  [07:07:10.134] Packages needed by future strategies (n = 0): <none>
  [07:07:10.142] {
  [07:07:10.142]     {
  [07:07:10.142]         ...future.startTime <- base::Sys.time()
  [07:07:10.142]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:10.142]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:10.142]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:10.142]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:10.142]             future.resolve.recursive = NULL, width = 80L)
  [07:07:10.142]         {
  [07:07:10.142]             {
  [07:07:10.142]                 base::local({
  [07:07:10.142]                   has_future <- base::requireNamespace("future", 
  [07:07:10.142]                     quietly = TRUE)
  [07:07:10.142]                   version <- if (has_future) 
  [07:07:10.142]                     utils::packageVersion("future")
  [07:07:10.142]                   else NULL
  [07:07:10.142]                   if (!has_future || version < "1.8.0") {
  [07:07:10.142]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:07:10.142]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:07:10.142]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:10.142]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:10.142]                         "release", "version")], collapse = " "), 
  [07:07:10.142]                       hostname = base::Sys.info()[["nodename"]])
  [07:07:10.142]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:10.142]                       info)
  [07:07:10.142]                     info <- base::paste(info, collapse = "; ")
  [07:07:10.142]                     if (!has_future) {
  [07:07:10.142]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:10.142]                         info)
  [07:07:10.142]                     }
  [07:07:10.142]                     else {
  [07:07:10.142]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:10.142]                         info, version)
  [07:07:10.142]                     }
  [07:07:10.142]                     base::stop(msg)
  [07:07:10.142]                   }
  [07:07:10.142]                 })
  [07:07:10.142]             }
  [07:07:10.142]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:10.142]         }
  [07:07:10.142]     }
  [07:07:10.142]     if (base::is.na(NA)) {
  [07:07:10.142]     }
  [07:07:10.142]     else {
  [07:07:10.142]         if (NA) {
  [07:07:10.142]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:10.142]                 open = "w")
  [07:07:10.142]         }
  [07:07:10.142]         else {
  [07:07:10.142]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:10.142]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:10.142]         }
  [07:07:10.142]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:10.142]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:10.142]             base::sink(type = "output", split = FALSE)
  [07:07:10.142]             base::close(...future.stdout)
  [07:07:10.142]         }, add = TRUE)
  [07:07:10.142]     }
  [07:07:10.142]     ...future.frame <- base::sys.nframe()
  [07:07:10.142]     ...future.conditions <- base::list()
  [07:07:10.142]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:10.142]     ...future.result <- base::tryCatch({
  [07:07:10.142]         base::withCallingHandlers({
  [07:07:10.142]             ...future.value <- base::withVisible(base::local({
  [07:07:10.142]                 x[[i - 2]] + x[[i - 1]]
  [07:07:10.142]             }))
  [07:07:10.142]             future::FutureResult(value = ...future.value$value, 
  [07:07:10.142]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.142]                   ...future.rng), started = ...future.startTime, 
  [07:07:10.142]                 version = "1.8")
  [07:07:10.142]         }, condition = base::local({
  [07:07:10.142]             c <- base::c
  [07:07:10.142]             inherits <- base::inherits
  [07:07:10.142]             invokeRestart <- base::invokeRestart
  [07:07:10.142]             length <- base::length
  [07:07:10.142]             list <- base::list
  [07:07:10.142]             seq.int <- base::seq.int
  [07:07:10.142]             signalCondition <- base::signalCondition
  [07:07:10.142]             sys.calls <- base::sys.calls
  [07:07:10.142]             Sys.time <- base::Sys.time
  [07:07:10.142]             `[[` <- base::`[[`
  [07:07:10.142]             `+` <- base::`+`
  [07:07:10.142]             `<<-` <- base::`<<-`
  [07:07:10.142]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:10.142]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:10.142]                   3L)]
  [07:07:10.142]             }
  [07:07:10.142]             function(cond) {
  [07:07:10.142]                 if (inherits(cond, "error")) {
  [07:07:10.142]                   sessionInformation <- function() {
  [07:07:10.142]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:10.142]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:10.142]                       search = base::search(), system = base::Sys.info())
  [07:07:10.142]                   }
  [07:07:10.142]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.142]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:10.142]                     cond$call), session = sessionInformation(), 
  [07:07:10.142]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:10.142]                   signalCondition(cond)
  [07:07:10.142]                 }
  [07:07:10.142]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:07:10.142]                 ))) {
  [07:07:10.142]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:10.142]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.142]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:10.142]                   if (!signal) {
  [07:07:10.142]                     muffleCondition <- function (cond) 
  [07:07:10.142]                     {
  [07:07:10.142]                       inherits <- base::inherits
  [07:07:10.142]                       invokeRestart <- base::invokeRestart
  [07:07:10.142]                       muffled <- FALSE
  [07:07:10.142]                       if (inherits(cond, "message")) {
  [07:07:10.142]                         invokeRestart("muffleMessage")
  [07:07:10.142]                         muffled <- TRUE
  [07:07:10.142]                       }
  [07:07:10.142]                       else if (inherits(cond, "warning")) {
  [07:07:10.142]                         invokeRestart("muffleWarning")
  [07:07:10.142]                         muffled <- TRUE
  [07:07:10.142]                       }
  [07:07:10.142]                       else if (inherits(cond, "condition")) {
  [07:07:10.142]                         computeRestarts <- base::computeRestarts
  [07:07:10.142]                         grepl <- base::grepl
  [07:07:10.142]                         is.null <- base::is.null
  [07:07:10.142]                         restarts <- computeRestarts(cond)
  [07:07:10.142]                         for (restart in restarts) {
  [07:07:10.142]                           name <- restart$name
  [07:07:10.142]                           if (is.null(name)) 
  [07:07:10.142]                             next
  [07:07:10.142]                           if (!grepl("^muffle", name)) 
  [07:07:10.142]                             next
  [07:07:10.142]                           invokeRestart(restart)
  [07:07:10.142]                           muffled <- TRUE
  [07:07:10.142]                           break
  [07:07:10.142]                         }
  [07:07:10.142]                       }
  [07:07:10.142]                       invisible(muffled)
  [07:07:10.142]                     }
  [07:07:10.142]                     muffleCondition(cond)
  [07:07:10.142]                   }
  [07:07:10.142]                 }
  [07:07:10.142]             }
  [07:07:10.142]         }))
  [07:07:10.142]     }, error = function(ex) {
  [07:07:10.142]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:10.142]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.142]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:10.142]     }, finally = {
  [07:07:10.142]         {
  [07:07:10.142]             NULL
  [07:07:10.142]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:10.142]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:10.142]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:10.142]                 label = NULL, ...) 
  [07:07:10.142]             {
  [07:07:10.142]                 if (substitute) 
  [07:07:10.142]                   expr <- substitute(expr)
  [07:07:10.142]                 local <- as.logical(local)
  [07:07:10.142]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:10.142]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:10.142]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:10.142]                   label = label, ...)
  [07:07:10.142]                 if (!future$lazy) 
  [07:07:10.142]                   future <- run(future)
  [07:07:10.142]                 invisible(future)
  [07:07:10.142]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:10.142]         }
  [07:07:10.142]         base::options(...future.oldOptions)
  [07:07:10.142]     })
  [07:07:10.142]     Sys.time
  [07:07:10.142]     if (base::is.na(NA)) {
  [07:07:10.142]     }
  [07:07:10.142]     else {
  [07:07:10.142]         base::sink(type = "output", split = FALSE)
  [07:07:10.142]         if (NA) {
  [07:07:10.142]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:10.142]         }
  [07:07:10.142]         else {
  [07:07:10.142]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:10.142]         }
  [07:07:10.142]         base::close(...future.stdout)
  [07:07:10.142]         ...future.stdout <- NULL
  [07:07:10.142]     }
  [07:07:10.142]     ...future.result$conditions <- ...future.conditions
  [07:07:10.142]     ...future.result
  [07:07:10.142] }
  [07:07:10.149] plan(): Setting new future strategy stack:
  [07:07:10.149] List of future strategies:
  [07:07:10.149] 1. sequential:
  [07:07:10.149]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.149]    - tweaked: FALSE
  [07:07:10.149]    - call: NULL
  [07:07:10.151] plan(): nbrOfWorkers() = 1
  [07:07:10.152] plan(): Setting new future strategy stack:
  [07:07:10.153] List of future strategies:
  [07:07:10.153] 1. sequential:
  [07:07:10.153]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.153]    - tweaked: FALSE
  [07:07:10.153]    - call: NULL
  [07:07:10.155] plan(): nbrOfWorkers() = 1
  [07:07:10.155] SequentialFuture started (and completed)
  [07:07:10.157] plan(): Setting new future strategy stack:
  [07:07:10.157] List of future strategies:
  [07:07:10.157] 1. sequential:
  [07:07:10.157]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.157]    - tweaked: FALSE
  [07:07:10.157]    - call: plan(sequential)
  [07:07:10.159] plan(): nbrOfWorkers() = 1
  [07:07:10.159] SequentialFuture started (and completed)
  [1] 7778742049
  
  > ## Reset plan
  > plan(oplan)
  [07:07:10.161] plan(): Setting new future strategy stack:
  [07:07:10.162] List of future strategies:
  [07:07:10.162] 1. sequential:
  [07:07:10.162]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.162]    - tweaked: FALSE
  [07:07:10.162]    - call: future::plan("sequential")
  [07:07:10.163] 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') ...
  [07:07:10.195] plan(): Setting new future strategy stack:
  [07:07:10.196] List of future strategies:
  [07:07:10.196] 1. sequential:
  [07:07:10.196]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.196]    - tweaked: FALSE
  [07:07:10.196]    - call: plan(strategy)
  [07:07:10.197] 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[07:07:10.301] getGlobalsAndPackages() ...
  [07:07:10.301] Searching for globals...
  [07:07:10.312] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:07:10.312] Searching for globals ... DONE
  [07:07:10.313] Resolving globals: FALSE
  [07:07:10.315] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:07:10.316] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:07:10.316] - packages: [1] 'future'
  [07:07:10.317] getGlobalsAndPackages() ... DONE
   2[07:07:10.332] getGlobalsAndPackages() ...
  [07:07:10.333] Searching for globals...
  [07:07:10.347] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:07:10.348] Searching for globals ... DONE
  [07:07:10.349] Resolving globals: FALSE
  [07:07:10.351] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:07:10.352] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:07:10.352] - packages: [1] 'future'
  [07:07:10.353] getGlobalsAndPackages() ... DONE
   3[07:07:10.354] getGlobalsAndPackages() ...
  [07:07:10.354] Searching for globals...
  [07:07:10.363] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:07:10.364] Searching for globals ... DONE
  [07:07:10.364] Resolving globals: FALSE
  [07:07:10.366] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:07:10.367] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:07:10.367] - packages: [1] 'future'
  [07:07:10.368] getGlobalsAndPackages() ... DONE
   4[07:07:10.369] getGlobalsAndPackages() ...
  [07:07:10.369] Searching for globals...
  [07:07:10.378] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:07:10.379] Searching for globals ... DONE
  [07:07:10.379] Resolving globals: FALSE
  [07:07:10.381] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:07:10.382] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:07:10.382] - packages: [1] 'future'
  [07:07:10.383] getGlobalsAndPackages() ... DONE
  
  > message(".")
  .
  
  > ## Calculate and plot tiles
  > repeat {
  +   counts <- plot_what_is_done(counts)
  +   if (!any(sapply(counts, FUN = inherits, "Future"))) break
  + }
  [07:07:10.420] Packages needed by the future expression (n = 1): 'future'
  [07:07:10.421] Packages needed by future strategies (n = 0): <none>
  [07:07:10.434] {
  [07:07:10.434]     {
  [07:07:10.434]         ...future.startTime <- base::Sys.time()
  [07:07:10.434]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:10.434]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:10.434]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:10.434]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:10.434]             future.resolve.recursive = NULL, width = 80L)
  [07:07:10.434]         {
  [07:07:10.434]             {
  [07:07:10.434]                 {
  [07:07:10.434]                   base::local({
  [07:07:10.434]                     has_future <- base::requireNamespace("future", 
  [07:07:10.434]                       quietly = TRUE)
  [07:07:10.434]                     version <- if (has_future) 
  [07:07:10.434]                       utils::packageVersion("future")
  [07:07:10.434]                     else NULL
  [07:07:10.434]                     if (!has_future || version < "1.8.0") {
  [07:07:10.434]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:07:10.434]                         "", base::R.version$version.string), 
  [07:07:10.434]                         platform = base::sprintf("%s (%s-bit)", 
  [07:07:10.434]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:10.434]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:10.434]                           "release", "version")], collapse = " "), 
  [07:07:10.434]                         hostname = base::Sys.info()[["nodename"]])
  [07:07:10.434]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:10.434]                         info)
  [07:07:10.434]                       info <- base::paste(info, collapse = "; ")
  [07:07:10.434]                       if (!has_future) {
  [07:07:10.434]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:10.434]                           info)
  [07:07:10.434]                       }
  [07:07:10.434]                       else {
  [07:07:10.434]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:10.434]                           info, version)
  [07:07:10.434]                       }
  [07:07:10.434]                       base::stop(msg)
  [07:07:10.434]                     }
  [07:07:10.434]                   })
  [07:07:10.434]                 }
  [07:07:10.434]                 base::local({
  [07:07:10.434]                   for (pkg in "future") {
  [07:07:10.434]                     base::loadNamespace(pkg)
  [07:07:10.434]                     base::library(pkg, character.only = TRUE)
  [07:07:10.434]                   }
  [07:07:10.434]                 })
  [07:07:10.434]             }
  [07:07:10.434]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:10.434]         }
  [07:07:10.434]     }
  [07:07:10.434]     if (base::is.na(TRUE)) {
  [07:07:10.434]     }
  [07:07:10.434]     else {
  [07:07:10.434]         if (TRUE) {
  [07:07:10.434]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:10.434]                 open = "w")
  [07:07:10.434]         }
  [07:07:10.434]         else {
  [07:07:10.434]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:10.434]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:10.434]         }
  [07:07:10.434]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:10.434]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:10.434]             base::sink(type = "output", split = FALSE)
  [07:07:10.434]             base::close(...future.stdout)
  [07:07:10.434]         }, add = TRUE)
  [07:07:10.434]     }
  [07:07:10.434]     ...future.frame <- base::sys.nframe()
  [07:07:10.434]     ...future.conditions <- base::list()
  [07:07:10.434]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:10.434]     ...future.result <- base::tryCatch({
  [07:07:10.434]         base::withCallingHandlers({
  [07:07:10.434]             ...future.value <- base::withVisible(base::local({
  [07:07:10.434]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:07:10.434]                   ii, n), appendLF = FALSE)
  [07:07:10.434]                 fit <- mandelbrot(C)
  [07:07:10.434]                 delay(fit)
  [07:07:10.434]                 message(" done")
  [07:07:10.434]                 fit
  [07:07:10.434]             }))
  [07:07:10.434]             future::FutureResult(value = ...future.value$value, 
  [07:07:10.434]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.434]                   ...future.rng), started = ...future.startTime, 
  [07:07:10.434]                 version = "1.8")
  [07:07:10.434]         }, condition = base::local({
  [07:07:10.434]             c <- base::c
  [07:07:10.434]             inherits <- base::inherits
  [07:07:10.434]             invokeRestart <- base::invokeRestart
  [07:07:10.434]             length <- base::length
  [07:07:10.434]             list <- base::list
  [07:07:10.434]             seq.int <- base::seq.int
  [07:07:10.434]             signalCondition <- base::signalCondition
  [07:07:10.434]             sys.calls <- base::sys.calls
  [07:07:10.434]             Sys.time <- base::Sys.time
  [07:07:10.434]             `[[` <- base::`[[`
  [07:07:10.434]             `+` <- base::`+`
  [07:07:10.434]             `<<-` <- base::`<<-`
  [07:07:10.434]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:10.434]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:10.434]                   3L)]
  [07:07:10.434]             }
  [07:07:10.434]             function(cond) {
  [07:07:10.434]                 if (inherits(cond, "error")) {
  [07:07:10.434]                   sessionInformation <- function() {
  [07:07:10.434]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:10.434]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:10.434]                       search = base::search(), system = base::Sys.info())
  [07:07:10.434]                   }
  [07:07:10.434]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.434]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:10.434]                     cond$call), session = sessionInformation(), 
  [07:07:10.434]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:10.434]                   signalCondition(cond)
  [07:07:10.434]                 }
  [07:07:10.434]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:07:10.434]                 ))) {
  [07:07:10.434]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:10.434]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.434]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:10.434]                   if (!signal) {
  [07:07:10.434]                     muffleCondition <- function (cond) 
  [07:07:10.434]                     {
  [07:07:10.434]                       inherits <- base::inherits
  [07:07:10.434]                       invokeRestart <- base::invokeRestart
  [07:07:10.434]                       muffled <- FALSE
  [07:07:10.434]                       if (inherits(cond, "message")) {
  [07:07:10.434]                         invokeRestart("muffleMessage")
  [07:07:10.434]                         muffled <- TRUE
  [07:07:10.434]                       }
  [07:07:10.434]                       else if (inherits(cond, "warning")) {
  [07:07:10.434]                         invokeRestart("muffleWarning")
  [07:07:10.434]                         muffled <- TRUE
  [07:07:10.434]                       }
  [07:07:10.434]                       else if (inherits(cond, "condition")) {
  [07:07:10.434]                         computeRestarts <- base::computeRestarts
  [07:07:10.434]                         grepl <- base::grepl
  [07:07:10.434]                         is.null <- base::is.null
  [07:07:10.434]                         restarts <- computeRestarts(cond)
  [07:07:10.434]                         for (restart in restarts) {
  [07:07:10.434]                           name <- restart$name
  [07:07:10.434]                           if (is.null(name)) 
  [07:07:10.434]                             next
  [07:07:10.434]                           if (!grepl("^muffle", name)) 
  [07:07:10.434]                             next
  [07:07:10.434]                           invokeRestart(restart)
  [07:07:10.434]                           muffled <- TRUE
  [07:07:10.434]                           break
  [07:07:10.434]                         }
  [07:07:10.434]                       }
  [07:07:10.434]                       invisible(muffled)
  [07:07:10.434]                     }
  [07:07:10.434]                     muffleCondition(cond)
  [07:07:10.434]                   }
  [07:07:10.434]                 }
  [07:07:10.434]             }
  [07:07:10.434]         }))
  [07:07:10.434]     }, error = function(ex) {
  [07:07:10.434]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:10.434]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.434]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:10.434]     }, finally = {
  [07:07:10.434]         {
  [07:07:10.434]             NULL
  [07:07:10.434]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:10.434]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:10.434]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:10.434]                 label = NULL, ...) 
  [07:07:10.434]             {
  [07:07:10.434]                 if (substitute) 
  [07:07:10.434]                   expr <- substitute(expr)
  [07:07:10.434]                 local <- as.logical(local)
  [07:07:10.434]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:10.434]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:10.434]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:10.434]                   label = label, ...)
  [07:07:10.434]                 if (!future$lazy) 
  [07:07:10.434]                   future <- run(future)
  [07:07:10.434]                 invisible(future)
  [07:07:10.434]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:10.434]         }
  [07:07:10.434]         base::options(...future.oldOptions)
  [07:07:10.434]     })
  [07:07:10.434]     Sys.time
  [07:07:10.434]     if (base::is.na(TRUE)) {
  [07:07:10.434]     }
  [07:07:10.434]     else {
  [07:07:10.434]         base::sink(type = "output", split = FALSE)
  [07:07:10.434]         if (TRUE) {
  [07:07:10.434]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:10.434]         }
  [07:07:10.434]         else {
  [07:07:10.434]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:10.434]         }
  [07:07:10.434]         base::close(...future.stdout)
  [07:07:10.434]         ...future.stdout <- NULL
  [07:07:10.434]     }
  [07:07:10.434]     ...future.result$conditions <- ...future.conditions
  [07:07:10.434]     ...future.result
  [07:07:10.434] }
  [07:07:10.442] plan(): Setting new future strategy stack:
  [07:07:10.443] List of future strategies:
  [07:07:10.443] 1. sequential:
  [07:07:10.443]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.443]    - tweaked: FALSE
  [07:07:10.443]    - call: NULL
  [07:07:10.444] plan(): nbrOfWorkers() = 1
  [07:07:10.449] plan(): Setting new future strategy stack:
  [07:07:10.450] List of future strategies:
  [07:07:10.450] 1. sequential:
  [07:07:10.450]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.450]    - tweaked: FALSE
  [07:07:10.450]    - call: plan(strategy)
  [07:07:10.452] plan(): nbrOfWorkers() = 1
  [07:07:10.453] SequentialFuture started (and completed)
  [07:07:10.453] signalConditions() ...
  [07:07:10.454]  - include = 'immediateCondition'
  [07:07:10.454]  - exclude = 
  [07:07:10.455]  - resignal = FALSE
  [07:07:10.455]  - Number of conditions: 2
  [07:07:10.456] signalConditions() ... done
  Plotting tile #1 of 4 ...
  [07:07:10.457] signalConditions() ...
  [07:07:10.457]  - include = 'immediateCondition'
  [07:07:10.458]  - exclude = 
  [07:07:10.458]  - resignal = FALSE
  [07:07:10.459]  - Number of conditions: 2
  [07:07:10.459] signalConditions() ... done
  [07:07:10.460] Future state: 'finished'
  [07:07:10.460] signalConditions() ...
  [07:07:10.461]  - include = 'condition'
  [07:07:10.461]  - exclude = 'immediateCondition'
  [07:07:10.462]  - resignal = TRUE
  [07:07:10.462]  - Number of conditions: 2
  [07:07:10.463]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #1 of 4 ...[07:07:10.463]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:07:10.464] signalConditions() ... done
  [07:07:10.470] Packages needed by the future expression (n = 1): 'future'
  [07:07:10.471] Packages needed by future strategies (n = 0): <none>
  [07:07:10.475] {
  [07:07:10.475]     {
  [07:07:10.475]         ...future.startTime <- base::Sys.time()
  [07:07:10.475]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:10.475]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:10.475]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:10.475]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:10.475]             future.resolve.recursive = NULL, width = 80L)
  [07:07:10.475]         {
  [07:07:10.475]             {
  [07:07:10.475]                 {
  [07:07:10.475]                   base::local({
  [07:07:10.475]                     has_future <- base::requireNamespace("future", 
  [07:07:10.475]                       quietly = TRUE)
  [07:07:10.475]                     version <- if (has_future) 
  [07:07:10.475]                       utils::packageVersion("future")
  [07:07:10.475]                     else NULL
  [07:07:10.475]                     if (!has_future || version < "1.8.0") {
  [07:07:10.475]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:07:10.475]                         "", base::R.version$version.string), 
  [07:07:10.475]                         platform = base::sprintf("%s (%s-bit)", 
  [07:07:10.475]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:10.475]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:10.475]                           "release", "version")], collapse = " "), 
  [07:07:10.475]                         hostname = base::Sys.info()[["nodename"]])
  [07:07:10.475]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:10.475]                         info)
  [07:07:10.475]                       info <- base::paste(info, collapse = "; ")
  [07:07:10.475]                       if (!has_future) {
  [07:07:10.475]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:10.475]                           info)
  [07:07:10.475]                       }
  [07:07:10.475]                       else {
  [07:07:10.475]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:10.475]                           info, version)
  [07:07:10.475]                       }
  [07:07:10.475]                       base::stop(msg)
  [07:07:10.475]                     }
  [07:07:10.475]                   })
  [07:07:10.475]                 }
  [07:07:10.475]                 base::local({
  [07:07:10.475]                   for (pkg in "future") {
  [07:07:10.475]                     base::loadNamespace(pkg)
  [07:07:10.475]                     base::library(pkg, character.only = TRUE)
  [07:07:10.475]                   }
  [07:07:10.475]                 })
  [07:07:10.475]             }
  [07:07:10.475]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:10.475]         }
  [07:07:10.475]     }
  [07:07:10.475]     if (base::is.na(TRUE)) {
  [07:07:10.475]     }
  [07:07:10.475]     else {
  [07:07:10.475]         if (TRUE) {
  [07:07:10.475]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:10.475]                 open = "w")
  [07:07:10.475]         }
  [07:07:10.475]         else {
  [07:07:10.475]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:10.475]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:10.475]         }
  [07:07:10.475]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:10.475]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:10.475]             base::sink(type = "output", split = FALSE)
  [07:07:10.475]             base::close(...future.stdout)
  [07:07:10.475]         }, add = TRUE)
  [07:07:10.475]     }
  [07:07:10.475]     ...future.frame <- base::sys.nframe()
  [07:07:10.475]     ...future.conditions <- base::list()
  [07:07:10.475]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:10.475]     ...future.result <- base::tryCatch({
  [07:07:10.475]         base::withCallingHandlers({
  [07:07:10.475]             ...future.value <- base::withVisible(base::local({
  [07:07:10.475]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:07:10.475]                   ii, n), appendLF = FALSE)
  [07:07:10.475]                 fit <- mandelbrot(C)
  [07:07:10.475]                 delay(fit)
  [07:07:10.475]                 message(" done")
  [07:07:10.475]                 fit
  [07:07:10.475]             }))
  [07:07:10.475]             future::FutureResult(value = ...future.value$value, 
  [07:07:10.475]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.475]                   ...future.rng), started = ...future.startTime, 
  [07:07:10.475]                 version = "1.8")
  [07:07:10.475]         }, condition = base::local({
  [07:07:10.475]             c <- base::c
  [07:07:10.475]             inherits <- base::inherits
  [07:07:10.475]             invokeRestart <- base::invokeRestart
  [07:07:10.475]             length <- base::length
  [07:07:10.475]             list <- base::list
  [07:07:10.475]             seq.int <- base::seq.int
  [07:07:10.475]             signalCondition <- base::signalCondition
  [07:07:10.475]             sys.calls <- base::sys.calls
  [07:07:10.475]             Sys.time <- base::Sys.time
  [07:07:10.475]             `[[` <- base::`[[`
  [07:07:10.475]             `+` <- base::`+`
  [07:07:10.475]             `<<-` <- base::`<<-`
  [07:07:10.475]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:10.475]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:10.475]                   3L)]
  [07:07:10.475]             }
  [07:07:10.475]             function(cond) {
  [07:07:10.475]                 if (inherits(cond, "error")) {
  [07:07:10.475]                   sessionInformation <- function() {
  [07:07:10.475]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:10.475]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:10.475]                       search = base::search(), system = base::Sys.info())
  [07:07:10.475]                   }
  [07:07:10.475]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.475]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:10.475]                     cond$call), session = sessionInformation(), 
  [07:07:10.475]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:10.475]                   signalCondition(cond)
  [07:07:10.475]                 }
  [07:07:10.475]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:07:10.475]                 ))) {
  [07:07:10.475]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:10.475]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.475]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:10.475]                   if (!signal) {
  [07:07:10.475]                     muffleCondition <- function (cond) 
  [07:07:10.475]                     {
  [07:07:10.475]                       inherits <- base::inherits
  [07:07:10.475]                       invokeRestart <- base::invokeRestart
  [07:07:10.475]                       muffled <- FALSE
  [07:07:10.475]                       if (inherits(cond, "message")) {
  [07:07:10.475]                         invokeRestart("muffleMessage")
  [07:07:10.475]                         muffled <- TRUE
  [07:07:10.475]                       }
  [07:07:10.475]                       else if (inherits(cond, "warning")) {
  [07:07:10.475]                         invokeRestart("muffleWarning")
  [07:07:10.475]                         muffled <- TRUE
  [07:07:10.475]                       }
  [07:07:10.475]                       else if (inherits(cond, "condition")) {
  [07:07:10.475]                         computeRestarts <- base::computeRestarts
  [07:07:10.475]                         grepl <- base::grepl
  [07:07:10.475]                         is.null <- base::is.null
  [07:07:10.475]                         restarts <- computeRestarts(cond)
  [07:07:10.475]                         for (restart in restarts) {
  [07:07:10.475]                           name <- restart$name
  [07:07:10.475]                           if (is.null(name)) 
  [07:07:10.475]                             next
  [07:07:10.475]                           if (!grepl("^muffle", name)) 
  [07:07:10.475]                             next
  [07:07:10.475]                           invokeRestart(restart)
  [07:07:10.475]                           muffled <- TRUE
  [07:07:10.475]                           break
  [07:07:10.475]                         }
  [07:07:10.475]                       }
  [07:07:10.475]                       invisible(muffled)
  [07:07:10.475]                     }
  [07:07:10.475]                     muffleCondition(cond)
  [07:07:10.475]                   }
  [07:07:10.475]                 }
  [07:07:10.475]             }
  [07:07:10.475]         }))
  [07:07:10.475]     }, error = function(ex) {
  [07:07:10.475]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:10.475]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.475]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:10.475]     }, finally = {
  [07:07:10.475]         {
  [07:07:10.475]             NULL
  [07:07:10.475]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:10.475]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:10.475]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:10.475]                 label = NULL, ...) 
  [07:07:10.475]             {
  [07:07:10.475]                 if (substitute) 
  [07:07:10.475]                   expr <- substitute(expr)
  [07:07:10.475]                 local <- as.logical(local)
  [07:07:10.475]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:10.475]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:10.475]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:10.475]                   label = label, ...)
  [07:07:10.475]                 if (!future$lazy) 
  [07:07:10.475]                   future <- run(future)
  [07:07:10.475]                 invisible(future)
  [07:07:10.475]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:10.475]         }
  [07:07:10.475]         base::options(...future.oldOptions)
  [07:07:10.475]     })
  [07:07:10.475]     Sys.time
  [07:07:10.475]     if (base::is.na(TRUE)) {
  [07:07:10.475]     }
  [07:07:10.475]     else {
  [07:07:10.475]         base::sink(type = "output", split = FALSE)
  [07:07:10.475]         if (TRUE) {
  [07:07:10.475]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:10.475]         }
  [07:07:10.475]         else {
  [07:07:10.475]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:10.475]         }
  [07:07:10.475]         base::close(...future.stdout)
  [07:07:10.475]         ...future.stdout <- NULL
  [07:07:10.475]     }
  [07:07:10.475]     ...future.result$conditions <- ...future.conditions
  [07:07:10.475]     ...future.result
  [07:07:10.475] }
  [07:07:10.480] plan(): Setting new future strategy stack:
  [07:07:10.480] List of future strategies:
  [07:07:10.480] 1. sequential:
  [07:07:10.480]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.480]    - tweaked: FALSE
  [07:07:10.480]    - call: NULL
  [07:07:10.481] plan(): nbrOfWorkers() = 1
  [07:07:10.487] plan(): Setting new future strategy stack:
  [07:07:10.488] List of future strategies:
  [07:07:10.488] 1. sequential:
  [07:07:10.488]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.488]    - tweaked: FALSE
  [07:07:10.488]    - call: plan(strategy)
  [07:07:10.489] plan(): nbrOfWorkers() = 1
  [07:07:10.489] SequentialFuture started (and completed)
  [07:07:10.490] signalConditions() ...
  [07:07:10.490]  - include = 'immediateCondition'
  [07:07:10.490]  - exclude = 
  [07:07:10.490]  - resignal = FALSE
  [07:07:10.491]  - Number of conditions: 2
  [07:07:10.491] signalConditions() ... done
  Plotting tile #2 of 4 ...
  [07:07:10.492] signalConditions() ...
  [07:07:10.492]  - include = 'immediateCondition'
  [07:07:10.492]  - exclude = 
  [07:07:10.492]  - resignal = FALSE
  [07:07:10.493]  - Number of conditions: 2
  [07:07:10.493] signalConditions() ... done
  [07:07:10.493] Future state: 'finished'
  [07:07:10.494] signalConditions() ...
  [07:07:10.494]  - include = 'condition'
  [07:07:10.494]  - exclude = 'immediateCondition'
  [07:07:10.494]  - resignal = TRUE
  [07:07:10.495]  - Number of conditions: 2
  [07:07:10.495]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #2 of 4 ...[07:07:10.495]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:07:10.496] signalConditions() ... done
  [07:07:10.499] Packages needed by the future expression (n = 1): 'future'
  [07:07:10.499] Packages needed by future strategies (n = 0): <none>
  [07:07:10.512] {
  [07:07:10.512]     {
  [07:07:10.512]         ...future.startTime <- base::Sys.time()
  [07:07:10.512]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:10.512]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:10.512]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:10.512]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:10.512]             future.resolve.recursive = NULL, width = 80L)
  [07:07:10.512]         {
  [07:07:10.512]             {
  [07:07:10.512]                 {
  [07:07:10.512]                   base::local({
  [07:07:10.512]                     has_future <- base::requireNamespace("future", 
  [07:07:10.512]                       quietly = TRUE)
  [07:07:10.512]                     version <- if (has_future) 
  [07:07:10.512]                       utils::packageVersion("future")
  [07:07:10.512]                     else NULL
  [07:07:10.512]                     if (!has_future || version < "1.8.0") {
  [07:07:10.512]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:07:10.512]                         "", base::R.version$version.string), 
  [07:07:10.512]                         platform = base::sprintf("%s (%s-bit)", 
  [07:07:10.512]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:10.512]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:10.512]                           "release", "version")], collapse = " "), 
  [07:07:10.512]                         hostname = base::Sys.info()[["nodename"]])
  [07:07:10.512]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:10.512]                         info)
  [07:07:10.512]                       info <- base::paste(info, collapse = "; ")
  [07:07:10.512]                       if (!has_future) {
  [07:07:10.512]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:10.512]                           info)
  [07:07:10.512]                       }
  [07:07:10.512]                       else {
  [07:07:10.512]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:10.512]                           info, version)
  [07:07:10.512]                       }
  [07:07:10.512]                       base::stop(msg)
  [07:07:10.512]                     }
  [07:07:10.512]                   })
  [07:07:10.512]                 }
  [07:07:10.512]                 base::local({
  [07:07:10.512]                   for (pkg in "future") {
  [07:07:10.512]                     base::loadNamespace(pkg)
  [07:07:10.512]                     base::library(pkg, character.only = TRUE)
  [07:07:10.512]                   }
  [07:07:10.512]                 })
  [07:07:10.512]             }
  [07:07:10.512]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:10.512]         }
  [07:07:10.512]     }
  [07:07:10.512]     if (base::is.na(TRUE)) {
  [07:07:10.512]     }
  [07:07:10.512]     else {
  [07:07:10.512]         if (TRUE) {
  [07:07:10.512]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:10.512]                 open = "w")
  [07:07:10.512]         }
  [07:07:10.512]         else {
  [07:07:10.512]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:10.512]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:10.512]         }
  [07:07:10.512]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:10.512]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:10.512]             base::sink(type = "output", split = FALSE)
  [07:07:10.512]             base::close(...future.stdout)
  [07:07:10.512]         }, add = TRUE)
  [07:07:10.512]     }
  [07:07:10.512]     ...future.frame <- base::sys.nframe()
  [07:07:10.512]     ...future.conditions <- base::list()
  [07:07:10.512]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:10.512]     ...future.result <- base::tryCatch({
  [07:07:10.512]         base::withCallingHandlers({
  [07:07:10.512]             ...future.value <- base::withVisible(base::local({
  [07:07:10.512]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:07:10.512]                   ii, n), appendLF = FALSE)
  [07:07:10.512]                 fit <- mandelbrot(C)
  [07:07:10.512]                 delay(fit)
  [07:07:10.512]                 message(" done")
  [07:07:10.512]                 fit
  [07:07:10.512]             }))
  [07:07:10.512]             future::FutureResult(value = ...future.value$value, 
  [07:07:10.512]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.512]                   ...future.rng), started = ...future.startTime, 
  [07:07:10.512]                 version = "1.8")
  [07:07:10.512]         }, condition = base::local({
  [07:07:10.512]             c <- base::c
  [07:07:10.512]             inherits <- base::inherits
  [07:07:10.512]             invokeRestart <- base::invokeRestart
  [07:07:10.512]             length <- base::length
  [07:07:10.512]             list <- base::list
  [07:07:10.512]             seq.int <- base::seq.int
  [07:07:10.512]             signalCondition <- base::signalCondition
  [07:07:10.512]             sys.calls <- base::sys.calls
  [07:07:10.512]             Sys.time <- base::Sys.time
  [07:07:10.512]             `[[` <- base::`[[`
  [07:07:10.512]             `+` <- base::`+`
  [07:07:10.512]             `<<-` <- base::`<<-`
  [07:07:10.512]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:10.512]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:10.512]                   3L)]
  [07:07:10.512]             }
  [07:07:10.512]             function(cond) {
  [07:07:10.512]                 if (inherits(cond, "error")) {
  [07:07:10.512]                   sessionInformation <- function() {
  [07:07:10.512]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:10.512]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:10.512]                       search = base::search(), system = base::Sys.info())
  [07:07:10.512]                   }
  [07:07:10.512]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.512]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:10.512]                     cond$call), session = sessionInformation(), 
  [07:07:10.512]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:10.512]                   signalCondition(cond)
  [07:07:10.512]                 }
  [07:07:10.512]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:07:10.512]                 ))) {
  [07:07:10.512]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:10.512]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.512]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:10.512]                   if (!signal) {
  [07:07:10.512]                     muffleCondition <- function (cond) 
  [07:07:10.512]                     {
  [07:07:10.512]                       inherits <- base::inherits
  [07:07:10.512]                       invokeRestart <- base::invokeRestart
  [07:07:10.512]                       muffled <- FALSE
  [07:07:10.512]                       if (inherits(cond, "message")) {
  [07:07:10.512]                         invokeRestart("muffleMessage")
  [07:07:10.512]                         muffled <- TRUE
  [07:07:10.512]                       }
  [07:07:10.512]                       else if (inherits(cond, "warning")) {
  [07:07:10.512]                         invokeRestart("muffleWarning")
  [07:07:10.512]                         muffled <- TRUE
  [07:07:10.512]                       }
  [07:07:10.512]                       else if (inherits(cond, "condition")) {
  [07:07:10.512]                         computeRestarts <- base::computeRestarts
  [07:07:10.512]                         grepl <- base::grepl
  [07:07:10.512]                         is.null <- base::is.null
  [07:07:10.512]                         restarts <- computeRestarts(cond)
  [07:07:10.512]                         for (restart in restarts) {
  [07:07:10.512]                           name <- restart$name
  [07:07:10.512]                           if (is.null(name)) 
  [07:07:10.512]                             next
  [07:07:10.512]                           if (!grepl("^muffle", name)) 
  [07:07:10.512]                             next
  [07:07:10.512]                           invokeRestart(restart)
  [07:07:10.512]                           muffled <- TRUE
  [07:07:10.512]                           break
  [07:07:10.512]                         }
  [07:07:10.512]                       }
  [07:07:10.512]                       invisible(muffled)
  [07:07:10.512]                     }
  [07:07:10.512]                     muffleCondition(cond)
  [07:07:10.512]                   }
  [07:07:10.512]                 }
  [07:07:10.512]             }
  [07:07:10.512]         }))
  [07:07:10.512]     }, error = function(ex) {
  [07:07:10.512]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:10.512]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.512]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:10.512]     }, finally = {
  [07:07:10.512]         {
  [07:07:10.512]             NULL
  [07:07:10.512]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:10.512]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:10.512]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:10.512]                 label = NULL, ...) 
  [07:07:10.512]             {
  [07:07:10.512]                 if (substitute) 
  [07:07:10.512]                   expr <- substitute(expr)
  [07:07:10.512]                 local <- as.logical(local)
  [07:07:10.512]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:10.512]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:10.512]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:10.512]                   label = label, ...)
  [07:07:10.512]                 if (!future$lazy) 
  [07:07:10.512]                   future <- run(future)
  [07:07:10.512]                 invisible(future)
  [07:07:10.512]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:10.512]         }
  [07:07:10.512]         base::options(...future.oldOptions)
  [07:07:10.512]     })
  [07:07:10.512]     Sys.time
  [07:07:10.512]     if (base::is.na(TRUE)) {
  [07:07:10.512]     }
  [07:07:10.512]     else {
  [07:07:10.512]         base::sink(type = "output", split = FALSE)
  [07:07:10.512]         if (TRUE) {
  [07:07:10.512]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:10.512]         }
  [07:07:10.512]         else {
  [07:07:10.512]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:10.512]         }
  [07:07:10.512]         base::close(...future.stdout)
  [07:07:10.512]         ...future.stdout <- NULL
  [07:07:10.512]     }
  [07:07:10.512]     ...future.result$conditions <- ...future.conditions
  [07:07:10.512]     ...future.result
  [07:07:10.512] }
  [07:07:10.520] plan(): Setting new future strategy stack:
  [07:07:10.520] List of future strategies:
  [07:07:10.520] 1. sequential:
  [07:07:10.520]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.520]    - tweaked: FALSE
  [07:07:10.520]    - call: NULL
  [07:07:10.521] plan(): nbrOfWorkers() = 1
  [07:07:10.525] plan(): Setting new future strategy stack:
  [07:07:10.525] List of future strategies:
  [07:07:10.525] 1. sequential:
  [07:07:10.525]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.525]    - tweaked: FALSE
  [07:07:10.525]    - call: plan(strategy)
  [07:07:10.527] plan(): nbrOfWorkers() = 1
  [07:07:10.528] SequentialFuture started (and completed)
  [07:07:10.528] signalConditions() ...
  [07:07:10.529]  - include = 'immediateCondition'
  [07:07:10.529]  - exclude = 
  [07:07:10.530]  - resignal = FALSE
  [07:07:10.530]  - Number of conditions: 2
  [07:07:10.531] signalConditions() ... done
  Plotting tile #3 of 4 ...
  [07:07:10.532] signalConditions() ...
  [07:07:10.532]  - include = 'immediateCondition'
  [07:07:10.532]  - exclude = 
  [07:07:10.533]  - resignal = FALSE
  [07:07:10.533]  - Number of conditions: 2
  [07:07:10.534] signalConditions() ... done
  [07:07:10.534] Future state: 'finished'
  [07:07:10.535] signalConditions() ...
  [07:07:10.535]  - include = 'condition'
  [07:07:10.536]  - exclude = 'immediateCondition'
  [07:07:10.536]  - resignal = TRUE
  [07:07:10.537]  - Number of conditions: 2
  [07:07:10.537]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #3 of 4 ...[07:07:10.538]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:07:10.538] signalConditions() ... done
  [07:07:10.542] Packages needed by the future expression (n = 1): 'future'
  [07:07:10.543] Packages needed by future strategies (n = 0): <none>
  [07:07:10.551] {
  [07:07:10.551]     {
  [07:07:10.551]         ...future.startTime <- base::Sys.time()
  [07:07:10.551]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:10.551]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:10.551]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:10.551]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:10.551]             future.resolve.recursive = NULL, width = 80L)
  [07:07:10.551]         {
  [07:07:10.551]             {
  [07:07:10.551]                 {
  [07:07:10.551]                   base::local({
  [07:07:10.551]                     has_future <- base::requireNamespace("future", 
  [07:07:10.551]                       quietly = TRUE)
  [07:07:10.551]                     version <- if (has_future) 
  [07:07:10.551]                       utils::packageVersion("future")
  [07:07:10.551]                     else NULL
  [07:07:10.551]                     if (!has_future || version < "1.8.0") {
  [07:07:10.551]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:07:10.551]                         "", base::R.version$version.string), 
  [07:07:10.551]                         platform = base::sprintf("%s (%s-bit)", 
  [07:07:10.551]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:10.551]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:10.551]                           "release", "version")], collapse = " "), 
  [07:07:10.551]                         hostname = base::Sys.info()[["nodename"]])
  [07:07:10.551]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:10.551]                         info)
  [07:07:10.551]                       info <- base::paste(info, collapse = "; ")
  [07:07:10.551]                       if (!has_future) {
  [07:07:10.551]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:10.551]                           info)
  [07:07:10.551]                       }
  [07:07:10.551]                       else {
  [07:07:10.551]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:10.551]                           info, version)
  [07:07:10.551]                       }
  [07:07:10.551]                       base::stop(msg)
  [07:07:10.551]                     }
  [07:07:10.551]                   })
  [07:07:10.551]                 }
  [07:07:10.551]                 base::local({
  [07:07:10.551]                   for (pkg in "future") {
  [07:07:10.551]                     base::loadNamespace(pkg)
  [07:07:10.551]                     base::library(pkg, character.only = TRUE)
  [07:07:10.551]                   }
  [07:07:10.551]                 })
  [07:07:10.551]             }
  [07:07:10.551]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:10.551]         }
  [07:07:10.551]     }
  [07:07:10.551]     if (base::is.na(TRUE)) {
  [07:07:10.551]     }
  [07:07:10.551]     else {
  [07:07:10.551]         if (TRUE) {
  [07:07:10.551]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:10.551]                 open = "w")
  [07:07:10.551]         }
  [07:07:10.551]         else {
  [07:07:10.551]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:10.551]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:10.551]         }
  [07:07:10.551]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:10.551]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:10.551]             base::sink(type = "output", split = FALSE)
  [07:07:10.551]             base::close(...future.stdout)
  [07:07:10.551]         }, add = TRUE)
  [07:07:10.551]     }
  [07:07:10.551]     ...future.frame <- base::sys.nframe()
  [07:07:10.551]     ...future.conditions <- base::list()
  [07:07:10.551]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:10.551]     ...future.result <- base::tryCatch({
  [07:07:10.551]         base::withCallingHandlers({
  [07:07:10.551]             ...future.value <- base::withVisible(base::local({
  [07:07:10.551]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:07:10.551]                   ii, n), appendLF = FALSE)
  [07:07:10.551]                 fit <- mandelbrot(C)
  [07:07:10.551]                 delay(fit)
  [07:07:10.551]                 message(" done")
  [07:07:10.551]                 fit
  [07:07:10.551]             }))
  [07:07:10.551]             future::FutureResult(value = ...future.value$value, 
  [07:07:10.551]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.551]                   ...future.rng), started = ...future.startTime, 
  [07:07:10.551]                 version = "1.8")
  [07:07:10.551]         }, condition = base::local({
  [07:07:10.551]             c <- base::c
  [07:07:10.551]             inherits <- base::inherits
  [07:07:10.551]             invokeRestart <- base::invokeRestart
  [07:07:10.551]             length <- base::length
  [07:07:10.551]             list <- base::list
  [07:07:10.551]             seq.int <- base::seq.int
  [07:07:10.551]             signalCondition <- base::signalCondition
  [07:07:10.551]             sys.calls <- base::sys.calls
  [07:07:10.551]             Sys.time <- base::Sys.time
  [07:07:10.551]             `[[` <- base::`[[`
  [07:07:10.551]             `+` <- base::`+`
  [07:07:10.551]             `<<-` <- base::`<<-`
  [07:07:10.551]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:10.551]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:10.551]                   3L)]
  [07:07:10.551]             }
  [07:07:10.551]             function(cond) {
  [07:07:10.551]                 if (inherits(cond, "error")) {
  [07:07:10.551]                   sessionInformation <- function() {
  [07:07:10.551]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:10.551]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:10.551]                       search = base::search(), system = base::Sys.info())
  [07:07:10.551]                   }
  [07:07:10.551]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.551]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:10.551]                     cond$call), session = sessionInformation(), 
  [07:07:10.551]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:10.551]                   signalCondition(cond)
  [07:07:10.551]                 }
  [07:07:10.551]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:07:10.551]                 ))) {
  [07:07:10.551]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:07:10.551]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.551]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:10.551]                   if (!signal) {
  [07:07:10.551]                     muffleCondition <- function (cond) 
  [07:07:10.551]                     {
  [07:07:10.551]                       inherits <- base::inherits
  [07:07:10.551]                       invokeRestart <- base::invokeRestart
  [07:07:10.551]                       muffled <- FALSE
  [07:07:10.551]                       if (inherits(cond, "message")) {
  [07:07:10.551]                         invokeRestart("muffleMessage")
  [07:07:10.551]                         muffled <- TRUE
  [07:07:10.551]                       }
  [07:07:10.551]                       else if (inherits(cond, "warning")) {
  [07:07:10.551]                         invokeRestart("muffleWarning")
  [07:07:10.551]                         muffled <- TRUE
  [07:07:10.551]                       }
  [07:07:10.551]                       else if (inherits(cond, "condition")) {
  [07:07:10.551]                         computeRestarts <- base::computeRestarts
  [07:07:10.551]                         grepl <- base::grepl
  [07:07:10.551]                         is.null <- base::is.null
  [07:07:10.551]                         restarts <- computeRestarts(cond)
  [07:07:10.551]                         for (restart in restarts) {
  [07:07:10.551]                           name <- restart$name
  [07:07:10.551]                           if (is.null(name)) 
  [07:07:10.551]                             next
  [07:07:10.551]                           if (!grepl("^muffle", name)) 
  [07:07:10.551]                             next
  [07:07:10.551]                           invokeRestart(restart)
  [07:07:10.551]                           muffled <- TRUE
  [07:07:10.551]                           break
  [07:07:10.551]                         }
  [07:07:10.551]                       }
  [07:07:10.551]                       invisible(muffled)
  [07:07:10.551]                     }
  [07:07:10.551]                     muffleCondition(cond)
  [07:07:10.551]                   }
  [07:07:10.551]                 }
  [07:07:10.551]             }
  [07:07:10.551]         }))
  [07:07:10.551]     }, error = function(ex) {
  [07:07:10.551]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:10.551]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.551]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:10.551]     }, finally = {
  [07:07:10.551]         {
  [07:07:10.551]             NULL
  [07:07:10.551]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:10.551]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:10.551]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:07:10.551]                 label = NULL, ...) 
  [07:07:10.551]             {
  [07:07:10.551]                 if (substitute) 
  [07:07:10.551]                   expr <- substitute(expr)
  [07:07:10.551]                 local <- as.logical(local)
  [07:07:10.551]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:07:10.551]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:10.551]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:07:10.551]                   label = label, ...)
  [07:07:10.551]                 if (!future$lazy) 
  [07:07:10.551]                   future <- run(future)
  [07:07:10.551]                 invisible(future)
  [07:07:10.551]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:10.551]         }
  [07:07:10.551]         base::options(...future.oldOptions)
  [07:07:10.551]     })
  [07:07:10.551]     Sys.time
  [07:07:10.551]     if (base::is.na(TRUE)) {
  [07:07:10.551]     }
  [07:07:10.551]     else {
  [07:07:10.551]         base::sink(type = "output", split = FALSE)
  [07:07:10.551]         if (TRUE) {
  [07:07:10.551]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:10.551]         }
  [07:07:10.551]         else {
  [07:07:10.551]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:10.551]         }
  [07:07:10.551]         base::close(...future.stdout)
  [07:07:10.551]         ...future.stdout <- NULL
  [07:07:10.551]     }
  [07:07:10.551]     ...future.result$conditions <- ...future.conditions
  [07:07:10.551]     ...future.result
  [07:07:10.551] }
  [07:07:10.559] plan(): Setting new future strategy stack:
  [07:07:10.560] List of future strategies:
  [07:07:10.560] 1. sequential:
  [07:07:10.560]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.560]    - tweaked: FALSE
  [07:07:10.560]    - call: NULL
  [07:07:10.561] plan(): nbrOfWorkers() = 1
  [07:07:10.568] plan(): Setting new future strategy stack:
  [07:07:10.568] List of future strategies:
  [07:07:10.568] 1. sequential:
  [07:07:10.568]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.568]    - tweaked: FALSE
  [07:07:10.568]    - call: plan(strategy)
  [07:07:10.570] plan(): nbrOfWorkers() = 1
  [07:07:10.571] SequentialFuture started (and completed)
  [07:07:10.571] signalConditions() ...
  [07:07:10.572]  - include = 'immediateCondition'
  [07:07:10.572]  - exclude = 
  [07:07:10.573]  - resignal = FALSE
  [07:07:10.573]  - Number of conditions: 2
  [07:07:10.574] signalConditions() ... done
  Plotting tile #4 of 4 ...
  [07:07:10.575] signalConditions() ...
  [07:07:10.575]  - include = 'immediateCondition'
  [07:07:10.575]  - exclude = 
  [07:07:10.576]  - resignal = FALSE
  [07:07:10.576]  - Number of conditions: 2
  [07:07:10.577] signalConditions() ... done
  [07:07:10.577] Future state: 'finished'
  [07:07:10.578] signalConditions() ...
  [07:07:10.578]  - include = 'condition'
  [07:07:10.579]  - exclude = 'immediateCondition'
  [07:07:10.579]  - resignal = TRUE
  [07:07:10.580]  - Number of conditions: 2
  [07:07:10.580]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #4 of 4 ...[07:07:10.581]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:07:10.581] 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') ...
  [07:07:10.610] plan(): Setting new future strategy stack:
  [07:07:10.610] List of future strategies:
  [07:07:10.610] 1. multicore:
  [07:07:10.610]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:07:10.610]    - tweaked: FALSE
  [07:07:10.610]    - call: plan(strategy)
  [07:07:10.612] 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[07:07:10.622] getGlobalsAndPackages() ...
  [07:07:10.623] Searching for globals...
  [07:07:10.632] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:07:10.632] Searching for globals ... DONE
  [07:07:10.633] Resolving globals: FALSE
  [07:07:10.634] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:07:10.635] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:07:10.635] - packages: [1] 'future'
  [07:07:10.636] getGlobalsAndPackages() ... DONE
   2[07:07:10.651] getGlobalsAndPackages() ...
  [07:07:10.652] Searching for globals...
  [07:07:10.661] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:07:10.662] Searching for globals ... DONE
  [07:07:10.662] Resolving globals: FALSE
  [07:07:10.664] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:07:10.665] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:07:10.665] - packages: [1] 'future'
  [07:07:10.666] getGlobalsAndPackages() ... DONE
   3[07:07:10.668] getGlobalsAndPackages() ...
  [07:07:10.668] Searching for globals...
  [07:07:10.677] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:07:10.677] Searching for globals ... DONE
  [07:07:10.678] Resolving globals: FALSE
  [07:07:10.685] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:07:10.686] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:07:10.686] - packages: [1] 'future'
  [07:07:10.687] getGlobalsAndPackages() ... DONE
   4[07:07:10.689] getGlobalsAndPackages() ...
  [07:07:10.689] Searching for globals...
  [07:07:10.699] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:07:10.699] Searching for globals ... DONE
  [07:07:10.700] Resolving globals: FALSE
  [07:07:10.702] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:07:10.703] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:07:10.703] - packages: [1] 'future'
  [07:07:10.704] getGlobalsAndPackages() ... DONE
  
  > message(".")
  .
  
  > ## Calculate and plot tiles
  > repeat {
  +   counts <- plot_what_is_done(counts)
  +   if (!any(sapply(counts, FUN = inherits, "Future"))) break
  + }
  [07:07:10.742] Packages needed by the future expression (n = 0): <none>
  [07:07:10.743] Packages needed by future strategies (n = 0): <none>
  [07:07:10.751] {
  [07:07:10.751]     {
  [07:07:10.751]         ...future.startTime <- base::Sys.time()
  [07:07:10.751]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:10.751]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:10.751]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:10.751]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:10.751]             future.resolve.recursive = NULL, width = 80L)
  [07:07:10.751]         {
  [07:07:10.751]             {
  [07:07:10.751]                 {
  [07:07:10.751]                   base::local({
  [07:07:10.751]                     has_future <- base::requireNamespace("future", 
  [07:07:10.751]                       quietly = TRUE)
  [07:07:10.751]                     version <- if (has_future) 
  [07:07:10.751]                       utils::packageVersion("future")
  [07:07:10.751]                     else NULL
  [07:07:10.751]                     if (!has_future || version < "1.8.0") {
  [07:07:10.751]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:07:10.751]                         "", base::R.version$version.string), 
  [07:07:10.751]                         platform = base::sprintf("%s (%s-bit)", 
  [07:07:10.751]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:10.751]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:10.751]                           "release", "version")], collapse = " "), 
  [07:07:10.751]                         hostname = base::Sys.info()[["nodename"]])
  [07:07:10.751]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:10.751]                         info)
  [07:07:10.751]                       info <- base::paste(info, collapse = "; ")
  [07:07:10.751]                       if (!has_future) {
  [07:07:10.751]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:10.751]                           info)
  [07:07:10.751]                       }
  [07:07:10.751]                       else {
  [07:07:10.751]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:10.751]                           info, version)
  [07:07:10.751]                       }
  [07:07:10.751]                       base::stop(msg)
  [07:07:10.751]                     }
  [07:07:10.751]                   })
  [07:07:10.751]                 }
  [07:07:10.751]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:07:10.751]                 base::options(mc.cores = 1L)
  [07:07:10.751]             }
  [07:07:10.751]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:10.751]         }
  [07:07:10.751]     }
  [07:07:10.751]     if (base::is.na(TRUE)) {
  [07:07:10.751]     }
  [07:07:10.751]     else {
  [07:07:10.751]         if (TRUE) {
  [07:07:10.751]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:10.751]                 open = "w")
  [07:07:10.751]         }
  [07:07:10.751]         else {
  [07:07:10.751]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:10.751]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:10.751]         }
  [07:07:10.751]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:10.751]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:10.751]             base::sink(type = "output", split = FALSE)
  [07:07:10.751]             base::close(...future.stdout)
  [07:07:10.751]         }, add = TRUE)
  [07:07:10.751]     }
  [07:07:10.751]     ...future.frame <- base::sys.nframe()
  [07:07:10.751]     ...future.conditions <- base::list()
  [07:07:10.751]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:10.751]     ...future.result <- base::tryCatch({
  [07:07:10.751]         base::withCallingHandlers({
  [07:07:10.751]             ...future.value <- base::withVisible(base::local({
  [07:07:10.751]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:07:10.751]                   ii, n), appendLF = FALSE)
  [07:07:10.751]                 fit <- mandelbrot(C)
  [07:07:10.751]                 delay(fit)
  [07:07:10.751]                 message(" done")
  [07:07:10.751]                 fit
  [07:07:10.751]             }))
  [07:07:10.751]             future::FutureResult(value = ...future.value$value, 
  [07:07:10.751]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.751]                   ...future.rng), started = ...future.startTime, 
  [07:07:10.751]                 version = "1.8")
  [07:07:10.751]         }, condition = base::local({
  [07:07:10.751]             c <- base::c
  [07:07:10.751]             inherits <- base::inherits
  [07:07:10.751]             invokeRestart <- base::invokeRestart
  [07:07:10.751]             length <- base::length
  [07:07:10.751]             list <- base::list
  [07:07:10.751]             seq.int <- base::seq.int
  [07:07:10.751]             signalCondition <- base::signalCondition
  [07:07:10.751]             sys.calls <- base::sys.calls
  [07:07:10.751]             Sys.time <- base::Sys.time
  [07:07:10.751]             `[[` <- base::`[[`
  [07:07:10.751]             `+` <- base::`+`
  [07:07:10.751]             `<<-` <- base::`<<-`
  [07:07:10.751]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:10.751]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:10.751]                   3L)]
  [07:07:10.751]             }
  [07:07:10.751]             function(cond) {
  [07:07:10.751]                 if (inherits(cond, "error")) {
  [07:07:10.751]                   sessionInformation <- function() {
  [07:07:10.751]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:10.751]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:10.751]                       search = base::search(), system = base::Sys.info())
  [07:07:10.751]                   }
  [07:07:10.751]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.751]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:10.751]                     cond$call), session = sessionInformation(), 
  [07:07:10.751]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:10.751]                   signalCondition(cond)
  [07:07:10.751]                 }
  [07:07:10.751]                 else if (inherits(cond, "condition")) {
  [07:07:10.751]                   signal <- FALSE && inherits(cond, character(0))
  [07:07:10.751]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.751]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:10.751]                   if (!signal) {
  [07:07:10.751]                     muffleCondition <- function (cond) 
  [07:07:10.751]                     {
  [07:07:10.751]                       inherits <- base::inherits
  [07:07:10.751]                       invokeRestart <- base::invokeRestart
  [07:07:10.751]                       muffled <- FALSE
  [07:07:10.751]                       if (inherits(cond, "message")) {
  [07:07:10.751]                         invokeRestart("muffleMessage")
  [07:07:10.751]                         muffled <- TRUE
  [07:07:10.751]                       }
  [07:07:10.751]                       else if (inherits(cond, "warning")) {
  [07:07:10.751]                         invokeRestart("muffleWarning")
  [07:07:10.751]                         muffled <- TRUE
  [07:07:10.751]                       }
  [07:07:10.751]                       else if (inherits(cond, "condition")) {
  [07:07:10.751]                         computeRestarts <- base::computeRestarts
  [07:07:10.751]                         grepl <- base::grepl
  [07:07:10.751]                         is.null <- base::is.null
  [07:07:10.751]                         restarts <- computeRestarts(cond)
  [07:07:10.751]                         for (restart in restarts) {
  [07:07:10.751]                           name <- restart$name
  [07:07:10.751]                           if (is.null(name)) 
  [07:07:10.751]                             next
  [07:07:10.751]                           if (!grepl("^muffle", name)) 
  [07:07:10.751]                             next
  [07:07:10.751]                           invokeRestart(restart)
  [07:07:10.751]                           muffled <- TRUE
  [07:07:10.751]                           break
  [07:07:10.751]                         }
  [07:07:10.751]                       }
  [07:07:10.751]                       invisible(muffled)
  [07:07:10.751]                     }
  [07:07:10.751]                     muffleCondition(cond)
  [07:07:10.751]                   }
  [07:07:10.751]                 }
  [07:07:10.751]             }
  [07:07:10.751]         }))
  [07:07:10.751]     }, error = function(ex) {
  [07:07:10.751]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:10.751]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.751]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:10.751]     }, finally = {
  [07:07:10.751]         {
  [07:07:10.751]             {
  [07:07:10.751]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:07:10.751]             }
  [07:07:10.751]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:10.751]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:10.751]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:07:10.751]                 earlySignal = FALSE, label = NULL, ...) 
  [07:07:10.751]             {
  [07:07:10.751]                 if (substitute) 
  [07:07:10.751]                   expr <- substitute(expr)
  [07:07:10.751]                 if (is.function(workers)) 
  [07:07:10.751]                   workers <- workers()
  [07:07:10.751]                 workers <- as.integer(workers)
  [07:07:10.751]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:07:10.751]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:07:10.751]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:07:10.751]                     lazy = lazy, seed = seed, globals = globals, 
  [07:07:10.751]                     local = TRUE, label = label, ...))
  [07:07:10.751]                 }
  [07:07:10.751]                 oopts <- options(mc.cores = workers)
  [07:07:10.751]                 on.exit(options(oopts))
  [07:07:10.751]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:07:10.751]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:10.751]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:07:10.751]                   label = label, ...)
  [07:07:10.751]                 if (!future$lazy) 
  [07:07:10.751]                   future <- run(future)
  [07:07:10.751]                 invisible(future)
  [07:07:10.751]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:10.751]         }
  [07:07:10.751]         base::options(...future.oldOptions)
  [07:07:10.751]     })
  [07:07:10.751]     Sys.time
  [07:07:10.751]     if (base::is.na(TRUE)) {
  [07:07:10.751]     }
  [07:07:10.751]     else {
  [07:07:10.751]         base::sink(type = "output", split = FALSE)
  [07:07:10.751]         if (TRUE) {
  [07:07:10.751]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:10.751]         }
  [07:07:10.751]         else {
  [07:07:10.751]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:10.751]         }
  [07:07:10.751]         base::close(...future.stdout)
  [07:07:10.751]         ...future.stdout <- NULL
  [07:07:10.751]     }
  [07:07:10.751]     ...future.result$conditions <- ...future.conditions
  [07:07:10.751]     ...future.result
  [07:07:10.751] }
  [07:07:10.758] requestCore(): workers = 2
  [07:07:10.774] MulticoreFuture started
  [07:07:10.781] plan(): Setting new future strategy stack:
  [07:07:10.782] List of future strategies:
  [07:07:10.782] 1. sequential:
  [07:07:10.782]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.782]    - tweaked: FALSE
  [07:07:10.782]    - call: NULL
  [07:07:10.786] plan(): nbrOfWorkers() = 1
  [07:07:10.787] Packages needed by the future expression (n = 0): <none>
  [07:07:10.788] Packages needed by future strategies (n = 0): <none>
  [07:07:10.794] plan(): Setting new future strategy stack:
  [07:07:10.795] List of future strategies:
  [07:07:10.795] 1. multicore:
  [07:07:10.795]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:07:10.795]    - tweaked: FALSE
  [07:07:10.795]    - call: plan(strategy)
  [07:07:10.799] plan(): nbrOfWorkers() = 2
  [07:07:10.805] {
  [07:07:10.805]     {
  [07:07:10.805]         ...future.startTime <- base::Sys.time()
  [07:07:10.805]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:10.805]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:10.805]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:10.805]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:10.805]             future.resolve.recursive = NULL, width = 80L)
  [07:07:10.805]         {
  [07:07:10.805]             {
  [07:07:10.805]                 {
  [07:07:10.805]                   base::local({
  [07:07:10.805]                     has_future <- base::requireNamespace("future", 
  [07:07:10.805]                       quietly = TRUE)
  [07:07:10.805]                     version <- if (has_future) 
  [07:07:10.805]                       utils::packageVersion("future")
  [07:07:10.805]                     else NULL
  [07:07:10.805]                     if (!has_future || version < "1.8.0") {
  [07:07:10.805]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:07:10.805]                         "", base::R.version$version.string), 
  [07:07:10.805]                         platform = base::sprintf("%s (%s-bit)", 
  [07:07:10.805]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:10.805]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:10.805]                           "release", "version")], collapse = " "), 
  [07:07:10.805]                         hostname = base::Sys.info()[["nodename"]])
  [07:07:10.805]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:10.805]                         info)
  [07:07:10.805]                       info <- base::paste(info, collapse = "; ")
  [07:07:10.805]                       if (!has_future) {
  [07:07:10.805]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:10.805]                           info)
  [07:07:10.805]                       }
  [07:07:10.805]                       else {
  [07:07:10.805]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:10.805]                           info, version)
  [07:07:10.805]                       }
  [07:07:10.805]                       base::stop(msg)
  [07:07:10.805]                     }
  [07:07:10.805]                   })
  [07:07:10.805]                 }
  [07:07:10.805]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:07:10.805]                 base::options(mc.cores = 1L)
  [07:07:10.805]             }
  [07:07:10.805]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:10.805]         }
  [07:07:10.805]     }
  [07:07:10.805]     if (base::is.na(TRUE)) {
  [07:07:10.805]     }
  [07:07:10.805]     else {
  [07:07:10.805]         if (TRUE) {
  [07:07:10.805]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:10.805]                 open = "w")
  [07:07:10.805]         }
  [07:07:10.805]         else {
  [07:07:10.805]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:10.805]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:10.805]         }
  [07:07:10.805]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:10.805]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:10.805]             base::sink(type = "output", split = FALSE)
  [07:07:10.805]             base::close(...future.stdout)
  [07:07:10.805]         }, add = TRUE)
  [07:07:10.805]     }
  [07:07:10.805]     ...future.frame <- base::sys.nframe()
  [07:07:10.805]     ...future.conditions <- base::list()
  [07:07:10.805]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:10.805]     ...future.result <- base::tryCatch({
  [07:07:10.805]         base::withCallingHandlers({
  [07:07:10.805]             ...future.value <- base::withVisible(base::local({
  [07:07:10.805]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:07:10.805]                   ii, n), appendLF = FALSE)
  [07:07:10.805]                 fit <- mandelbrot(C)
  [07:07:10.805]                 delay(fit)
  [07:07:10.805]                 message(" done")
  [07:07:10.805]                 fit
  [07:07:10.805]             }))
  [07:07:10.805]             future::FutureResult(value = ...future.value$value, 
  [07:07:10.805]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.805]                   ...future.rng), started = ...future.startTime, 
  [07:07:10.805]                 version = "1.8")
  [07:07:10.805]         }, condition = base::local({
  [07:07:10.805]             c <- base::c
  [07:07:10.805]             inherits <- base::inherits
  [07:07:10.805]             invokeRestart <- base::invokeRestart
  [07:07:10.805]             length <- base::length
  [07:07:10.805]             list <- base::list
  [07:07:10.805]             seq.int <- base::seq.int
  [07:07:10.805]             signalCondition <- base::signalCondition
  [07:07:10.805]             sys.calls <- base::sys.calls
  [07:07:10.805]             Sys.time <- base::Sys.time
  [07:07:10.805]             `[[` <- base::`[[`
  [07:07:10.805]             `+` <- base::`+`
  [07:07:10.805]             `<<-` <- base::`<<-`
  [07:07:10.805]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:10.805]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:10.805]                   3L)]
  [07:07:10.805]             }
  [07:07:10.805]             function(cond) {
  [07:07:10.805]                 if (inherits(cond, "error")) {
  [07:07:10.805]                   sessionInformation <- function() {
  [07:07:10.805]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:10.805]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:10.805]                       search = base::search(), system = base::Sys.info())
  [07:07:10.805]                   }
  [07:07:10.805]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.805]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:10.805]                     cond$call), session = sessionInformation(), 
  [07:07:10.805]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:10.805]                   signalCondition(cond)
  [07:07:10.805]                 }
  [07:07:10.805]                 else if (inherits(cond, "condition")) {
  [07:07:10.805]                   signal <- FALSE && inherits(cond, character(0))
  [07:07:10.805]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.805]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:10.805]                   if (!signal) {
  [07:07:10.805]                     muffleCondition <- function (cond) 
  [07:07:10.805]                     {
  [07:07:10.805]                       inherits <- base::inherits
  [07:07:10.805]                       invokeRestart <- base::invokeRestart
  [07:07:10.805]                       muffled <- FALSE
  [07:07:10.805]                       if (inherits(cond, "message")) {
  [07:07:10.805]                         invokeRestart("muffleMessage")
  [07:07:10.805]                         muffled <- TRUE
  [07:07:10.805]                       }
  [07:07:10.805]                       else if (inherits(cond, "warning")) {
  [07:07:10.805]                         invokeRestart("muffleWarning")
  [07:07:10.805]                         muffled <- TRUE
  [07:07:10.805]                       }
  [07:07:10.805]                       else if (inherits(cond, "condition")) {
  [07:07:10.805]                         computeRestarts <- base::computeRestarts
  [07:07:10.805]                         grepl <- base::grepl
  [07:07:10.805]                         is.null <- base::is.null
  [07:07:10.805]                         restarts <- computeRestarts(cond)
  [07:07:10.805]                         for (restart in restarts) {
  [07:07:10.805]                           name <- restart$name
  [07:07:10.805]                           if (is.null(name)) 
  [07:07:10.805]                             next
  [07:07:10.805]                           if (!grepl("^muffle", name)) 
  [07:07:10.805]                             next
  [07:07:10.805]                           invokeRestart(restart)
  [07:07:10.805]                           muffled <- TRUE
  [07:07:10.805]                           break
  [07:07:10.805]                         }
  [07:07:10.805]                       }
  [07:07:10.805]                       invisible(muffled)
  [07:07:10.805]                     }
  [07:07:10.805]                     muffleCondition(cond)
  [07:07:10.805]                   }
  [07:07:10.805]                 }
  [07:07:10.805]             }
  [07:07:10.805]         }))
  [07:07:10.805]     }, error = function(ex) {
  [07:07:10.805]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:10.805]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.805]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:10.805]     }, finally = {
  [07:07:10.805]         {
  [07:07:10.805]             {
  [07:07:10.805]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:07:10.805]             }
  [07:07:10.805]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:10.805]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:10.805]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:07:10.805]                 earlySignal = FALSE, label = NULL, ...) 
  [07:07:10.805]             {
  [07:07:10.805]                 if (substitute) 
  [07:07:10.805]                   expr <- substitute(expr)
  [07:07:10.805]                 if (is.function(workers)) 
  [07:07:10.805]                   workers <- workers()
  [07:07:10.805]                 workers <- as.integer(workers)
  [07:07:10.805]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:07:10.805]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:07:10.805]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:07:10.805]                     lazy = lazy, seed = seed, globals = globals, 
  [07:07:10.805]                     local = TRUE, label = label, ...))
  [07:07:10.805]                 }
  [07:07:10.805]                 oopts <- options(mc.cores = workers)
  [07:07:10.805]                 on.exit(options(oopts))
  [07:07:10.805]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:07:10.805]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:10.805]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:07:10.805]                   label = label, ...)
  [07:07:10.805]                 if (!future$lazy) 
  [07:07:10.805]                   future <- run(future)
  [07:07:10.805]                 invisible(future)
  [07:07:10.805]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:10.805]         }
  [07:07:10.805]         base::options(...future.oldOptions)
  [07:07:10.805]     })
  [07:07:10.805]     Sys.time
  [07:07:10.805]     if (base::is.na(TRUE)) {
  [07:07:10.805]     }
  [07:07:10.805]     else {
  [07:07:10.805]         base::sink(type = "output", split = FALSE)
  [07:07:10.805]         if (TRUE) {
  [07:07:10.805]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:10.805]         }
  [07:07:10.805]         else {
  [07:07:10.805]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:10.805]         }
  [07:07:10.805]         base::close(...future.stdout)
  [07:07:10.805]         ...future.stdout <- NULL
  [07:07:10.805]     }
  [07:07:10.805]     ...future.result$conditions <- ...future.conditions
  [07:07:10.805]     ...future.result
  [07:07:10.805] }
  [07:07:10.813] requestCore(): workers = 2
  [07:07:10.830] MulticoreFuture started
  [07:07:10.836] plan(): Setting new future strategy stack:
  Plotting tile #1 of 4 ...
  [07:07:10.837] List of future strategies:
  [07:07:10.837] 1. sequential:
  [07:07:10.837]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.837]    - tweaked: FALSE
  [07:07:10.837]    - call: NULL
  [07:07:10.839] plan(): nbrOfWorkers() = 1
  [07:07:10.846] signalConditions() ...
  [07:07:10.846]  - include = 'immediateCondition'
  [07:07:10.847]  - exclude = 
  [07:07:10.848]  - resignal = FALSE
  [07:07:10.848]  - Number of conditions: 2
  [07:07:10.849] signalConditions() ... done
  [07:07:10.850] signalConditions() ...
  [07:07:10.851]  - include = 'immediateCondition'
  [07:07:10.851]  - exclude = 
  [07:07:10.852]  - resignal = FALSE
  [07:07:10.852]  - Number of conditions: 2
  [07:07:10.853] signalConditions() ... done
  [07:07:10.854] Future state: 'finished'
  [07:07:10.854] plan(): Setting new future strategy stack:
  [07:07:10.855] signalConditions() ...
  [07:07:10.855]  - include = 'condition'
  [07:07:10.855] List of future strategies:
  [07:07:10.855] 1. multicore:
  [07:07:10.855]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:07:10.855]    - tweaked: FALSE
  [07:07:10.855]    - call: plan(strategy)
  [07:07:10.858] plan(): nbrOfWorkers() = 2
  [07:07:10.856]  - exclude = 'immediateCondition'
  [07:07:10.863]  - resignal = TRUE
  [07:07:10.863]  - Number of conditions: 2
  [07:07:10.864]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #1 of 4 ...[07:07:10.865]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:07:10.865] signalConditions() ... done
  Plotting tile #2 of 4 ...
  [07:07:10.871] signalConditions() ...
  [07:07:10.872]  - include = 'immediateCondition'
  [07:07:10.873]  - exclude = 
  [07:07:10.873]  - resignal = FALSE
  [07:07:10.874]  - Number of conditions: 2
  [07:07:10.875] signalConditions() ... done
  [07:07:10.876] signalConditions() ...
  [07:07:10.876]  - include = 'immediateCondition'
  [07:07:10.877]  - exclude = 
  [07:07:10.877]  - resignal = FALSE
  [07:07:10.878]  - Number of conditions: 2
  [07:07:10.878] signalConditions() ... done
  [07:07:10.879] Future state: 'finished'
  [07:07:10.879] signalConditions() ...
  [07:07:10.880]  - include = 'condition'
  [07:07:10.880]  - exclude = 'immediateCondition'
  [07:07:10.881]  - resignal = TRUE
  [07:07:10.881]  - Number of conditions: 2
  [07:07:10.882]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #2 of 4 ...[07:07:10.883]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:07:10.883] signalConditions() ... done
  [07:07:10.887] Packages needed by the future expression (n = 0): <none>
  [07:07:10.887] Packages needed by future strategies (n = 0): <none>
  [07:07:10.893] {
  [07:07:10.893]     {
  [07:07:10.893]         ...future.startTime <- base::Sys.time()
  [07:07:10.893]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:10.893]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:10.893]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:10.893]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:10.893]             future.resolve.recursive = NULL, width = 80L)
  [07:07:10.893]         {
  [07:07:10.893]             {
  [07:07:10.893]                 {
  [07:07:10.893]                   base::local({
  [07:07:10.893]                     has_future <- base::requireNamespace("future", 
  [07:07:10.893]                       quietly = TRUE)
  [07:07:10.893]                     version <- if (has_future) 
  [07:07:10.893]                       utils::packageVersion("future")
  [07:07:10.893]                     else NULL
  [07:07:10.893]                     if (!has_future || version < "1.8.0") {
  [07:07:10.893]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:07:10.893]                         "", base::R.version$version.string), 
  [07:07:10.893]                         platform = base::sprintf("%s (%s-bit)", 
  [07:07:10.893]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:10.893]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:10.893]                           "release", "version")], collapse = " "), 
  [07:07:10.893]                         hostname = base::Sys.info()[["nodename"]])
  [07:07:10.893]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:10.893]                         info)
  [07:07:10.893]                       info <- base::paste(info, collapse = "; ")
  [07:07:10.893]                       if (!has_future) {
  [07:07:10.893]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:10.893]                           info)
  [07:07:10.893]                       }
  [07:07:10.893]                       else {
  [07:07:10.893]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:10.893]                           info, version)
  [07:07:10.893]                       }
  [07:07:10.893]                       base::stop(msg)
  [07:07:10.893]                     }
  [07:07:10.893]                   })
  [07:07:10.893]                 }
  [07:07:10.893]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:07:10.893]                 base::options(mc.cores = 1L)
  [07:07:10.893]             }
  [07:07:10.893]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:10.893]         }
  [07:07:10.893]     }
  [07:07:10.893]     if (base::is.na(TRUE)) {
  [07:07:10.893]     }
  [07:07:10.893]     else {
  [07:07:10.893]         if (TRUE) {
  [07:07:10.893]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:10.893]                 open = "w")
  [07:07:10.893]         }
  [07:07:10.893]         else {
  [07:07:10.893]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:10.893]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:10.893]         }
  [07:07:10.893]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:10.893]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:10.893]             base::sink(type = "output", split = FALSE)
  [07:07:10.893]             base::close(...future.stdout)
  [07:07:10.893]         }, add = TRUE)
  [07:07:10.893]     }
  [07:07:10.893]     ...future.frame <- base::sys.nframe()
  [07:07:10.893]     ...future.conditions <- base::list()
  [07:07:10.893]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:10.893]     ...future.result <- base::tryCatch({
  [07:07:10.893]         base::withCallingHandlers({
  [07:07:10.893]             ...future.value <- base::withVisible(base::local({
  [07:07:10.893]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:07:10.893]                   ii, n), appendLF = FALSE)
  [07:07:10.893]                 fit <- mandelbrot(C)
  [07:07:10.893]                 delay(fit)
  [07:07:10.893]                 message(" done")
  [07:07:10.893]                 fit
  [07:07:10.893]             }))
  [07:07:10.893]             future::FutureResult(value = ...future.value$value, 
  [07:07:10.893]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.893]                   ...future.rng), started = ...future.startTime, 
  [07:07:10.893]                 version = "1.8")
  [07:07:10.893]         }, condition = base::local({
  [07:07:10.893]             c <- base::c
  [07:07:10.893]             inherits <- base::inherits
  [07:07:10.893]             invokeRestart <- base::invokeRestart
  [07:07:10.893]             length <- base::length
  [07:07:10.893]             list <- base::list
  [07:07:10.893]             seq.int <- base::seq.int
  [07:07:10.893]             signalCondition <- base::signalCondition
  [07:07:10.893]             sys.calls <- base::sys.calls
  [07:07:10.893]             Sys.time <- base::Sys.time
  [07:07:10.893]             `[[` <- base::`[[`
  [07:07:10.893]             `+` <- base::`+`
  [07:07:10.893]             `<<-` <- base::`<<-`
  [07:07:10.893]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:10.893]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:10.893]                   3L)]
  [07:07:10.893]             }
  [07:07:10.893]             function(cond) {
  [07:07:10.893]                 if (inherits(cond, "error")) {
  [07:07:10.893]                   sessionInformation <- function() {
  [07:07:10.893]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:10.893]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:10.893]                       search = base::search(), system = base::Sys.info())
  [07:07:10.893]                   }
  [07:07:10.893]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.893]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:10.893]                     cond$call), session = sessionInformation(), 
  [07:07:10.893]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:10.893]                   signalCondition(cond)
  [07:07:10.893]                 }
  [07:07:10.893]                 else if (inherits(cond, "condition")) {
  [07:07:10.893]                   signal <- FALSE && inherits(cond, character(0))
  [07:07:10.893]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.893]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:10.893]                   if (!signal) {
  [07:07:10.893]                     muffleCondition <- function (cond) 
  [07:07:10.893]                     {
  [07:07:10.893]                       inherits <- base::inherits
  [07:07:10.893]                       invokeRestart <- base::invokeRestart
  [07:07:10.893]                       muffled <- FALSE
  [07:07:10.893]                       if (inherits(cond, "message")) {
  [07:07:10.893]                         invokeRestart("muffleMessage")
  [07:07:10.893]                         muffled <- TRUE
  [07:07:10.893]                       }
  [07:07:10.893]                       else if (inherits(cond, "warning")) {
  [07:07:10.893]                         invokeRestart("muffleWarning")
  [07:07:10.893]                         muffled <- TRUE
  [07:07:10.893]                       }
  [07:07:10.893]                       else if (inherits(cond, "condition")) {
  [07:07:10.893]                         computeRestarts <- base::computeRestarts
  [07:07:10.893]                         grepl <- base::grepl
  [07:07:10.893]                         is.null <- base::is.null
  [07:07:10.893]                         restarts <- computeRestarts(cond)
  [07:07:10.893]                         for (restart in restarts) {
  [07:07:10.893]                           name <- restart$name
  [07:07:10.893]                           if (is.null(name)) 
  [07:07:10.893]                             next
  [07:07:10.893]                           if (!grepl("^muffle", name)) 
  [07:07:10.893]                             next
  [07:07:10.893]                           invokeRestart(restart)
  [07:07:10.893]                           muffled <- TRUE
  [07:07:10.893]                           break
  [07:07:10.893]                         }
  [07:07:10.893]                       }
  [07:07:10.893]                       invisible(muffled)
  [07:07:10.893]                     }
  [07:07:10.893]                     muffleCondition(cond)
  [07:07:10.893]                   }
  [07:07:10.893]                 }
  [07:07:10.893]             }
  [07:07:10.893]         }))
  [07:07:10.893]     }, error = function(ex) {
  [07:07:10.893]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:10.893]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.893]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:10.893]     }, finally = {
  [07:07:10.893]         {
  [07:07:10.893]             {
  [07:07:10.893]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:07:10.893]             }
  [07:07:10.893]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:10.893]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:10.893]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:07:10.893]                 earlySignal = FALSE, label = NULL, ...) 
  [07:07:10.893]             {
  [07:07:10.893]                 if (substitute) 
  [07:07:10.893]                   expr <- substitute(expr)
  [07:07:10.893]                 if (is.function(workers)) 
  [07:07:10.893]                   workers <- workers()
  [07:07:10.893]                 workers <- as.integer(workers)
  [07:07:10.893]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:07:10.893]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:07:10.893]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:07:10.893]                     lazy = lazy, seed = seed, globals = globals, 
  [07:07:10.893]                     local = TRUE, label = label, ...))
  [07:07:10.893]                 }
  [07:07:10.893]                 oopts <- options(mc.cores = workers)
  [07:07:10.893]                 on.exit(options(oopts))
  [07:07:10.893]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:07:10.893]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:10.893]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:07:10.893]                   label = label, ...)
  [07:07:10.893]                 if (!future$lazy) 
  [07:07:10.893]                   future <- run(future)
  [07:07:10.893]                 invisible(future)
  [07:07:10.893]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:10.893]         }
  [07:07:10.893]         base::options(...future.oldOptions)
  [07:07:10.893]     })
  [07:07:10.893]     Sys.time
  [07:07:10.893]     if (base::is.na(TRUE)) {
  [07:07:10.893]     }
  [07:07:10.893]     else {
  [07:07:10.893]         base::sink(type = "output", split = FALSE)
  [07:07:10.893]         if (TRUE) {
  [07:07:10.893]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:10.893]         }
  [07:07:10.893]         else {
  [07:07:10.893]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:10.893]         }
  [07:07:10.893]         base::close(...future.stdout)
  [07:07:10.893]         ...future.stdout <- NULL
  [07:07:10.893]     }
  [07:07:10.893]     ...future.result$conditions <- ...future.conditions
  [07:07:10.893]     ...future.result
  [07:07:10.893] }
  [07:07:10.897] requestCore(): workers = 2
  [07:07:10.902] MulticoreFuture started
  [07:07:10.907] plan(): Setting new future strategy stack:
  [07:07:10.908] Packages needed by the future expression (n = 0): <none>
  [07:07:10.909] Packages needed by future strategies (n = 0): <none>
  [07:07:10.908] List of future strategies:
  [07:07:10.908] 1. sequential:
  [07:07:10.908]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.908]    - tweaked: FALSE
  [07:07:10.908]    - call: NULL
  [07:07:10.911] plan(): nbrOfWorkers() = 1
  [07:07:10.928] plan(): Setting new future strategy stack:
  [07:07:10.932] List of future strategies:
  [07:07:10.932] 1. multicore:
  [07:07:10.932]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:07:10.932]    - tweaked: FALSE
  [07:07:10.932]    - call: plan(strategy)
  [07:07:10.936] plan(): nbrOfWorkers() = 2
  [07:07:10.941] {
  [07:07:10.941]     {
  [07:07:10.941]         ...future.startTime <- base::Sys.time()
  [07:07:10.941]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:07:10.941]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:07:10.941]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:07:10.941]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:07:10.941]             future.resolve.recursive = NULL, width = 80L)
  [07:07:10.941]         {
  [07:07:10.941]             {
  [07:07:10.941]                 {
  [07:07:10.941]                   base::local({
  [07:07:10.941]                     has_future <- base::requireNamespace("future", 
  [07:07:10.941]                       quietly = TRUE)
  [07:07:10.941]                     version <- if (has_future) 
  [07:07:10.941]                       utils::packageVersion("future")
  [07:07:10.941]                     else NULL
  [07:07:10.941]                     if (!has_future || version < "1.8.0") {
  [07:07:10.941]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:07:10.941]                         "", base::R.version$version.string), 
  [07:07:10.941]                         platform = base::sprintf("%s (%s-bit)", 
  [07:07:10.941]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:07:10.941]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:07:10.941]                           "release", "version")], collapse = " "), 
  [07:07:10.941]                         hostname = base::Sys.info()[["nodename"]])
  [07:07:10.941]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:07:10.941]                         info)
  [07:07:10.941]                       info <- base::paste(info, collapse = "; ")
  [07:07:10.941]                       if (!has_future) {
  [07:07:10.941]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:07:10.941]                           info)
  [07:07:10.941]                       }
  [07:07:10.941]                       else {
  [07:07:10.941]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:07:10.941]                           info, version)
  [07:07:10.941]                       }
  [07:07:10.941]                       base::stop(msg)
  [07:07:10.941]                     }
  [07:07:10.941]                   })
  [07:07:10.941]                 }
  [07:07:10.941]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:07:10.941]                 base::options(mc.cores = 1L)
  [07:07:10.941]             }
  [07:07:10.941]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:07:10.941]         }
  [07:07:10.941]     }
  [07:07:10.941]     if (base::is.na(TRUE)) {
  [07:07:10.941]     }
  [07:07:10.941]     else {
  [07:07:10.941]         if (TRUE) {
  [07:07:10.941]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:07:10.941]                 open = "w")
  [07:07:10.941]         }
  [07:07:10.941]         else {
  [07:07:10.941]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:07:10.941]                 windows = "NUL", "/dev/null"), open = "w")
  [07:07:10.941]         }
  [07:07:10.941]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:07:10.941]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:07:10.941]             base::sink(type = "output", split = FALSE)
  [07:07:10.941]             base::close(...future.stdout)
  [07:07:10.941]         }, add = TRUE)
  [07:07:10.941]     }
  [07:07:10.941]     ...future.frame <- base::sys.nframe()
  [07:07:10.941]     ...future.conditions <- base::list()
  [07:07:10.941]     ...future.rng <- base::globalenv()$.Random.seed
  [07:07:10.941]     ...future.result <- base::tryCatch({
  [07:07:10.941]         base::withCallingHandlers({
  [07:07:10.941]             ...future.value <- base::withVisible(base::local({
  [07:07:10.941]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:07:10.941]                   ii, n), appendLF = FALSE)
  [07:07:10.941]                 fit <- mandelbrot(C)
  [07:07:10.941]                 delay(fit)
  [07:07:10.941]                 message(" done")
  [07:07:10.941]                 fit
  [07:07:10.941]             }))
  [07:07:10.941]             future::FutureResult(value = ...future.value$value, 
  [07:07:10.941]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.941]                   ...future.rng), started = ...future.startTime, 
  [07:07:10.941]                 version = "1.8")
  [07:07:10.941]         }, condition = base::local({
  [07:07:10.941]             c <- base::c
  [07:07:10.941]             inherits <- base::inherits
  [07:07:10.941]             invokeRestart <- base::invokeRestart
  [07:07:10.941]             length <- base::length
  [07:07:10.941]             list <- base::list
  [07:07:10.941]             seq.int <- base::seq.int
  [07:07:10.941]             signalCondition <- base::signalCondition
  [07:07:10.941]             sys.calls <- base::sys.calls
  [07:07:10.941]             Sys.time <- base::Sys.time
  [07:07:10.941]             `[[` <- base::`[[`
  [07:07:10.941]             `+` <- base::`+`
  [07:07:10.941]             `<<-` <- base::`<<-`
  [07:07:10.941]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:07:10.941]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:07:10.941]                   3L)]
  [07:07:10.941]             }
  [07:07:10.941]             function(cond) {
  [07:07:10.941]                 if (inherits(cond, "error")) {
  [07:07:10.941]                   sessionInformation <- function() {
  [07:07:10.941]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:07:10.941]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:07:10.941]                       search = base::search(), system = base::Sys.info())
  [07:07:10.941]                   }
  [07:07:10.941]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.941]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:07:10.941]                     cond$call), session = sessionInformation(), 
  [07:07:10.941]                     timestamp = Sys.time(), signaled = 0L)
  [07:07:10.941]                   signalCondition(cond)
  [07:07:10.941]                 }
  [07:07:10.941]                 else if (inherits(cond, "condition")) {
  [07:07:10.941]                   signal <- FALSE && inherits(cond, character(0))
  [07:07:10.941]                   ...future.conditions[[length(...future.conditions) + 
  [07:07:10.941]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:07:10.941]                   if (!signal) {
  [07:07:10.941]                     muffleCondition <- function (cond) 
  [07:07:10.941]                     {
  [07:07:10.941]                       inherits <- base::inherits
  [07:07:10.941]                       invokeRestart <- base::invokeRestart
  [07:07:10.941]                       muffled <- FALSE
  [07:07:10.941]                       if (inherits(cond, "message")) {
  [07:07:10.941]                         invokeRestart("muffleMessage")
  [07:07:10.941]                         muffled <- TRUE
  [07:07:10.941]                       }
  [07:07:10.941]                       else if (inherits(cond, "warning")) {
  [07:07:10.941]                         invokeRestart("muffleWarning")
  [07:07:10.941]                         muffled <- TRUE
  [07:07:10.941]                       }
  [07:07:10.941]                       else if (inherits(cond, "condition")) {
  [07:07:10.941]                         computeRestarts <- base::computeRestarts
  [07:07:10.941]                         grepl <- base::grepl
  [07:07:10.941]                         is.null <- base::is.null
  [07:07:10.941]                         restarts <- computeRestarts(cond)
  [07:07:10.941]                         for (restart in restarts) {
  [07:07:10.941]                           name <- restart$name
  [07:07:10.941]                           if (is.null(name)) 
  [07:07:10.941]                             next
  [07:07:10.941]                           if (!grepl("^muffle", name)) 
  [07:07:10.941]                             next
  [07:07:10.941]                           invokeRestart(restart)
  [07:07:10.941]                           muffled <- TRUE
  [07:07:10.941]                           break
  [07:07:10.941]                         }
  [07:07:10.941]                       }
  [07:07:10.941]                       invisible(muffled)
  [07:07:10.941]                     }
  [07:07:10.941]                     muffleCondition(cond)
  [07:07:10.941]                   }
  [07:07:10.941]                 }
  [07:07:10.941]             }
  [07:07:10.941]         }))
  [07:07:10.941]     }, error = function(ex) {
  [07:07:10.941]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:07:10.941]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:07:10.941]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:07:10.941]     }, finally = {
  [07:07:10.941]         {
  [07:07:10.941]             {
  [07:07:10.941]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:07:10.941]             }
  [07:07:10.941]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:07:10.941]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:07:10.941]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:07:10.941]                 earlySignal = FALSE, label = NULL, ...) 
  [07:07:10.941]             {
  [07:07:10.941]                 if (substitute) 
  [07:07:10.941]                   expr <- substitute(expr)
  [07:07:10.941]                 if (is.function(workers)) 
  [07:07:10.941]                   workers <- workers()
  [07:07:10.941]                 workers <- as.integer(workers)
  [07:07:10.941]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:07:10.941]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:07:10.941]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:07:10.941]                     lazy = lazy, seed = seed, globals = globals, 
  [07:07:10.941]                     local = TRUE, label = label, ...))
  [07:07:10.941]                 }
  [07:07:10.941]                 oopts <- options(mc.cores = workers)
  [07:07:10.941]                 on.exit(options(oopts))
  [07:07:10.941]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:07:10.941]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:07:10.941]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:07:10.941]                   label = label, ...)
  [07:07:10.941]                 if (!future$lazy) 
  [07:07:10.941]                   future <- run(future)
  [07:07:10.941]                 invisible(future)
  [07:07:10.941]             }), .cleanup = FALSE, .init = FALSE)
  [07:07:10.941]         }
  [07:07:10.941]         base::options(...future.oldOptions)
  [07:07:10.941]     })
  [07:07:10.941]     Sys.time
  [07:07:10.941]     if (base::is.na(TRUE)) {
  [07:07:10.941]     }
  [07:07:10.941]     else {
  [07:07:10.941]         base::sink(type = "output", split = FALSE)
  [07:07:10.941]         if (TRUE) {
  [07:07:10.941]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:07:10.941]         }
  [07:07:10.941]         else {
  [07:07:10.941]             ...future.result["stdout"] <- base::list(NULL)
  [07:07:10.941]         }
  [07:07:10.941]         base::close(...future.stdout)
  [07:07:10.941]         ...future.stdout <- NULL
  [07:07:10.941]     }
  [07:07:10.941]     ...future.result$conditions <- ...future.conditions
  [07:07:10.941]     ...future.result
  [07:07:10.941] }
  [07:07:10.950] requestCore(): workers = 2
  [07:07:10.956] MulticoreFuture started
  Plotting tile #3 of 4 ...
  [07:07:10.963] plan(): Setting new future strategy stack:
  [07:07:10.965] signalConditions() ...
  [07:07:10.967]  - include = 'immediateCondition'
  [07:07:10.968]  - exclude = 
  [07:07:10.970]  - resignal = FALSE
  [07:07:10.971]  - Number of conditions: 2
  [07:07:10.965] List of future strategies:
  [07:07:10.965] 1. sequential:
  [07:07:10.965]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:07:10.965]    - tweaked: FALSE
  [07:07:10.965]    - call: NULL
  [07:07:10.972] signalConditions() ... done
  [07:07:10.973] plan(): nbrOfWorkers() = 1
  [07:07:10.973] signalConditions() ...
  [07:07:10.974]  - include = 'immediateCondition'
  [07:07:10.975]  - exclude = 
  [07:07:10.976]  - resignal = FALSE
  [07:07:10.982]  - Number of conditions: 2
  [07:07:10.983] signalConditions() ... done
  [07:07:10.984] Future state: 'finished'
  [07:07:10.985] signalConditions() ...
  [07:07:10.986]  - include = 'condition'
  [07:07:10.986] plan(): Setting new future strategy stack:
  [07:07:10.987]  - exclude = 'immediateCondition'
  [07:07:10.988]  - resignal = TRUE
  [07:07:10.988]  - Number of conditions: 2
  [07:07:10.987] List of future strategies:
  [07:07:10.987] 1. multicore:
  [07:07:10.987]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:07:10.987]    - tweaked: FALSE
  [07:07:10.987]    - call: plan(strategy)
  [07:07:10.989]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #3 of 4 ...[07:07:10.990]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:07:10.991] signalConditions() ... done
  [07:07:10.991] plan(): nbrOfWorkers() = 2
  Plotting tile #4 of 4 ...
  [07:07:10.998] signalConditions() ...
  [07:07:10.999]  - include = 'immediateCondition'
  [07:07:10.999]  - exclude = 
  [07:07:11.000]  - resignal = FALSE
  [07:07:11.001]  - Number of conditions: 2
  [07:07:11.001] signalConditions() ... done
  [07:07:11.002] signalConditions() ...
  [07:07:11.003]  - include = 'immediateCondition'
  [07:07:11.003]  - exclude = 
  [07:07:11.004]  - resignal = FALSE
  [07:07:11.004]  - Number of conditions: 2
  [07:07:11.005] signalConditions() ... done
  [07:07:11.006] Future state: 'finished'
  [07:07:11.006] signalConditions() ...
  [07:07:11.007]  - include = 'condition'
  [07:07:11.007]  - exclude = 'immediateCondition'
  [07:07:11.008]  - resignal = TRUE
  [07:07:11.009]  - Number of conditions: 2
  [07:07:11.009]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #4 of 4 ...[07:07:11.015]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:07:11.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') ...
  [07:07:11.022] plan(): Setting new future strategy stack:
  [07:07:11.022] List of future strategies:
  [07:07:11.022] 1. multisession:
  [07:07:11.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, ...)
  [07:07:11.022]    - tweaked: FALSE
  [07:07:11.022]    - call: plan(strategy)
  [07:07:11.024] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [07:07:11.025] multisession:
  [07:07:11.025] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [07:07:11.025] - tweaked: FALSE
  [07:07:11.025] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 37131
  [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/Rtmpk6JOTc/working_dir/RtmpExpPpY/future.parent=665524.a27b46e22d604.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmpk6JOTc/working_dir/RtmpExpPpY/future.parent=665524.a27b46e22d604.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:665524' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpk6JOTc/working_dir/RtmpExpPpY/future.parent=665524.a27b46e22d604.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=37131 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 666558) if still alive
  [07:09:12.022] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(665524, signal = 0L)
  [1] TRUE
  Call: tools::pskill(665524, signal = 0L)
  [1] TRUE
  [07:09:12.023] - success
  [07:09:12.023] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 666558) 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 37131 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:665524' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpk6JOTc/working_dir/RtmpExpPpY/future.parent=665524.a27b46e22d604.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=37131 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 666558) 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")
  [07:09:12.434] plan(): Setting new future strategy stack:
  [07:09:12.435] List of future strategies:
  [07:09:12.435] 1. sequential:
  [07:09:12.435]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.435]    - tweaked: FALSE
  [07:09:12.435]    - call: future::plan("sequential")
  [07:09:12.436] 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') ...
  [07:09:12.556] plan(): Setting new future strategy stack:
  [07:09:12.557] List of future strategies:
  [07:09:12.557] 1. sequential:
  [07:09:12.557]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.557]    - tweaked: FALSE
  [07:09:12.557]    - call: plan(strategy, substitute = FALSE)
  [07:09:12.595] plan(): nbrOfWorkers() = 1
  ** Sum function 'A' with plan('sequential') ...
  function (x, ...) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, ...)
      }
      y
  }
  <bytecode: 0x3bd9290>
  Arguments '...' exists: TRUE
  [07:09:12.601] getGlobalsAndPackages() ...
  [07:09:12.602] Searching for globals...
  [07:09:12.615] - globals found: [4] '{', 'sum', 'x', '...'
  [07:09:12.616] Searching for globals ... DONE
  [07:09:12.617] Resolving globals: FALSE
  [07:09:12.617] Tweak future expression to call with '...' arguments ...
  [07:09:12.618] Tweak future expression to call with '...' arguments ... DONE
  [07:09:12.621] The total size of the 2 globals is 112 bytes (112 bytes)
  [07:09:12.622] - globals: [2] 'x', 'future.call.arguments'
  [07:09:12.623] 
  [07:09:12.623] getGlobalsAndPackages() ... DONE
  [07:09:12.628] Packages needed by the future expression (n = 0): <none>
  [07:09:12.629] Packages needed by future strategies (n = 0): <none>
  [07:09:12.641] {
  [07:09:12.641]     {
  [07:09:12.641]         ...future.startTime <- base::Sys.time()
  [07:09:12.641]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:09:12.641]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:09:12.641]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:09:12.641]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:09:12.641]             future.resolve.recursive = NULL, width = 80L)
  [07:09:12.641]         {
  [07:09:12.641]             {
  [07:09:12.641]                 base::local({
  [07:09:12.641]                   has_future <- base::requireNamespace("future", 
  [07:09:12.641]                     quietly = TRUE)
  [07:09:12.641]                   version <- if (has_future) 
  [07:09:12.641]                     utils::packageVersion("future")
  [07:09:12.641]                   else NULL
  [07:09:12.641]                   if (!has_future || version < "1.8.0") {
  [07:09:12.641]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:09:12.641]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:09:12.641]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:09:12.641]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:09:12.641]                         "release", "version")], collapse = " "), 
  [07:09:12.641]                       hostname = base::Sys.info()[["nodename"]])
  [07:09:12.641]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:09:12.641]                       info)
  [07:09:12.641]                     info <- base::paste(info, collapse = "; ")
  [07:09:12.641]                     if (!has_future) {
  [07:09:12.641]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:09:12.641]                         info)
  [07:09:12.641]                     }
  [07:09:12.641]                     else {
  [07:09:12.641]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:09:12.641]                         info, version)
  [07:09:12.641]                     }
  [07:09:12.641]                     base::stop(msg)
  [07:09:12.641]                   }
  [07:09:12.641]                 })
  [07:09:12.641]             }
  [07:09:12.641]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:09:12.641]         }
  [07:09:12.641]     }
  [07:09:12.641]     if (base::is.na(TRUE)) {
  [07:09:12.641]     }
  [07:09:12.641]     else {
  [07:09:12.641]         if (TRUE) {
  [07:09:12.641]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:09:12.641]                 open = "w")
  [07:09:12.641]         }
  [07:09:12.641]         else {
  [07:09:12.641]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:09:12.641]                 windows = "NUL", "/dev/null"), open = "w")
  [07:09:12.641]         }
  [07:09:12.641]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:09:12.641]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:09:12.641]             base::sink(type = "output", split = FALSE)
  [07:09:12.641]             base::close(...future.stdout)
  [07:09:12.641]         }, add = TRUE)
  [07:09:12.641]     }
  [07:09:12.641]     ...future.frame <- base::sys.nframe()
  [07:09:12.641]     ...future.conditions <- base::list()
  [07:09:12.641]     ...future.rng <- base::globalenv()$.Random.seed
  [07:09:12.641]     ...future.result <- base::tryCatch({
  [07:09:12.641]         base::withCallingHandlers({
  [07:09:12.641]             ...future.value <- base::withVisible(base::local({
  [07:09:12.641]                 sum(x, ...)
  [07:09:12.641]             }))
  [07:09:12.641]             future::FutureResult(value = ...future.value$value, 
  [07:09:12.641]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:09:12.641]                   ...future.rng), started = ...future.startTime, 
  [07:09:12.641]                 version = "1.8")
  [07:09:12.641]         }, condition = base::local({
  [07:09:12.641]             c <- base::c
  [07:09:12.641]             inherits <- base::inherits
  [07:09:12.641]             invokeRestart <- base::invokeRestart
  [07:09:12.641]             length <- base::length
  [07:09:12.641]             list <- base::list
  [07:09:12.641]             seq.int <- base::seq.int
  [07:09:12.641]             signalCondition <- base::signalCondition
  [07:09:12.641]             sys.calls <- base::sys.calls
  [07:09:12.641]             Sys.time <- base::Sys.time
  [07:09:12.641]             `[[` <- base::`[[`
  [07:09:12.641]             `+` <- base::`+`
  [07:09:12.641]             `<<-` <- base::`<<-`
  [07:09:12.641]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:09:12.641]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:09:12.641]                   3L)]
  [07:09:12.641]             }
  [07:09:12.641]             function(cond) {
  [07:09:12.641]                 if (inherits(cond, "error")) {
  [07:09:12.641]                   sessionInformation <- function() {
  [07:09:12.641]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:09:12.641]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:09:12.641]                       search = base::search(), system = base::Sys.info())
  [07:09:12.641]                   }
  [07:09:12.641]                   ...future.conditions[[length(...future.conditions) + 
  [07:09:12.641]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:09:12.641]                     cond$call), session = sessionInformation(), 
  [07:09:12.641]                     timestamp = Sys.time(), signaled = 0L)
  [07:09:12.641]                   signalCondition(cond)
  [07:09:12.641]                 }
  [07:09:12.641]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:09:12.641]                 ))) {
  [07:09:12.641]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:09:12.641]                   ...future.conditions[[length(...future.conditions) + 
  [07:09:12.641]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:09:12.641]                   if (!signal) {
  [07:09:12.641]                     muffleCondition <- function (cond) 
  [07:09:12.641]                     {
  [07:09:12.641]                       inherits <- base::inherits
  [07:09:12.641]                       invokeRestart <- base::invokeRestart
  [07:09:12.641]                       muffled <- FALSE
  [07:09:12.641]                       if (inherits(cond, "message")) {
  [07:09:12.641]                         invokeRestart("muffleMessage")
  [07:09:12.641]                         muffled <- TRUE
  [07:09:12.641]                       }
  [07:09:12.641]                       else if (inherits(cond, "warning")) {
  [07:09:12.641]                         invokeRestart("muffleWarning")
  [07:09:12.641]                         muffled <- TRUE
  [07:09:12.641]                       }
  [07:09:12.641]                       else if (inherits(cond, "condition")) {
  [07:09:12.641]                         computeRestarts <- base::computeRestarts
  [07:09:12.641]                         grepl <- base::grepl
  [07:09:12.641]                         is.null <- base::is.null
  [07:09:12.641]                         restarts <- computeRestarts(cond)
  [07:09:12.641]                         for (restart in restarts) {
  [07:09:12.641]                           name <- restart$name
  [07:09:12.641]                           if (is.null(name)) 
  [07:09:12.641]                             next
  [07:09:12.641]                           if (!grepl("^muffle", name)) 
  [07:09:12.641]                             next
  [07:09:12.641]                           invokeRestart(restart)
  [07:09:12.641]                           muffled <- TRUE
  [07:09:12.641]                           break
  [07:09:12.641]                         }
  [07:09:12.641]                       }
  [07:09:12.641]                       invisible(muffled)
  [07:09:12.641]                     }
  [07:09:12.641]                     muffleCondition(cond)
  [07:09:12.641]                   }
  [07:09:12.641]                 }
  [07:09:12.641]             }
  [07:09:12.641]         }))
  [07:09:12.641]     }, error = function(ex) {
  [07:09:12.641]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:09:12.641]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:09:12.641]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:09:12.641]     }, finally = {
  [07:09:12.641]         {
  [07:09:12.641]             NULL
  [07:09:12.641]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:09:12.641]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:09:12.641]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:09:12.641]                 label = NULL, ...) 
  [07:09:12.641]             {
  [07:09:12.641]                 if (substitute) 
  [07:09:12.641]                   expr <- substitute(expr)
  [07:09:12.641]                 local <- as.logical(local)
  [07:09:12.641]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:09:12.641]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:09:12.641]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:09:12.641]                   label = label, ...)
  [07:09:12.641]                 if (!future$lazy) 
  [07:09:12.641]                   future <- run(future)
  [07:09:12.641]                 invisible(future)
  [07:09:12.641]             }), .cleanup = FALSE, .init = FALSE)
  [07:09:12.641]         }
  [07:09:12.641]         base::options(...future.oldOptions)
  [07:09:12.641]     })
  [07:09:12.641]     Sys.time
  [07:09:12.641]     if (base::is.na(TRUE)) {
  [07:09:12.641]     }
  [07:09:12.641]     else {
  [07:09:12.641]         base::sink(type = "output", split = FALSE)
  [07:09:12.641]         if (TRUE) {
  [07:09:12.641]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:09:12.641]         }
  [07:09:12.641]         else {
  [07:09:12.641]             ...future.result["stdout"] <- base::list(NULL)
  [07:09:12.641]         }
  [07:09:12.641]         base::close(...future.stdout)
  [07:09:12.641]         ...future.stdout <- NULL
  [07:09:12.641]     }
  [07:09:12.641]     ...future.result$conditions <- ...future.conditions
  [07:09:12.641]     ...future.result
  [07:09:12.641] }
  [07:09:12.649] plan(): Setting new future strategy stack:
  [07:09:12.649] List of future strategies:
  [07:09:12.649] 1. sequential:
  [07:09:12.649]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.649]    - tweaked: FALSE
  [07:09:12.649]    - call: NULL
  [07:09:12.650] plan(): nbrOfWorkers() = 1
  [07:09:12.651] plan(): Setting new future strategy stack:
  [07:09:12.652] List of future strategies:
  [07:09:12.652] 1. sequential:
  [07:09:12.652]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.652]    - tweaked: FALSE
  [07:09:12.652]    - call: plan(strategy, substitute = FALSE)
  [07:09:12.652] plan(): nbrOfWorkers() = 1
  [07:09:12.653] 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: 0x4082648>
  Arguments '...' exists: TRUE
  [07:09:12.656] getGlobalsAndPackages() ...
  [07:09:12.656] Searching for globals...
  [07:09:12.658] - globals found: [4] '{', 'sum', 'x', '...'
  [07:09:12.659] Searching for globals ... DONE
  [07:09:12.659] Resolving globals: FALSE
  [07:09:12.660] Tweak future expression to call with '...' arguments ...
  [07:09:12.660] Tweak future expression to call with '...' arguments ... DONE
  [07:09:12.661] The total size of the 2 globals is 112 bytes (112 bytes)
  [07:09:12.661] - globals: [2] 'x', 'future.call.arguments'
  [07:09:12.662] 
  [07:09:12.662] getGlobalsAndPackages() ... DONE
  [07:09:12.664] Packages needed by the future expression (n = 0): <none>
  [07:09:12.664] Packages needed by future strategies (n = 0): <none>
  [07:09:12.668] {
  [07:09:12.668]     {
  [07:09:12.668]         ...future.startTime <- base::Sys.time()
  [07:09:12.668]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:09:12.668]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:09:12.668]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:09:12.668]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:09:12.668]             future.resolve.recursive = NULL, width = 80L)
  [07:09:12.668]         {
  [07:09:12.668]             {
  [07:09:12.668]                 base::local({
  [07:09:12.668]                   has_future <- base::requireNamespace("future", 
  [07:09:12.668]                     quietly = TRUE)
  [07:09:12.668]                   version <- if (has_future) 
  [07:09:12.668]                     utils::packageVersion("future")
  [07:09:12.668]                   else NULL
  [07:09:12.668]                   if (!has_future || version < "1.8.0") {
  [07:09:12.668]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:09:12.668]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:09:12.668]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:09:12.668]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:09:12.668]                         "release", "version")], collapse = " "), 
  [07:09:12.668]                       hostname = base::Sys.info()[["nodename"]])
  [07:09:12.668]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:09:12.668]                       info)
  [07:09:12.668]                     info <- base::paste(info, collapse = "; ")
  [07:09:12.668]                     if (!has_future) {
  [07:09:12.668]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:09:12.668]                         info)
  [07:09:12.668]                     }
  [07:09:12.668]                     else {
  [07:09:12.668]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:09:12.668]                         info, version)
  [07:09:12.668]                     }
  [07:09:12.668]                     base::stop(msg)
  [07:09:12.668]                   }
  [07:09:12.668]                 })
  [07:09:12.668]             }
  [07:09:12.668]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:09:12.668]         }
  [07:09:12.668]     }
  [07:09:12.668]     if (base::is.na(TRUE)) {
  [07:09:12.668]     }
  [07:09:12.668]     else {
  [07:09:12.668]         if (TRUE) {
  [07:09:12.668]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:09:12.668]                 open = "w")
  [07:09:12.668]         }
  [07:09:12.668]         else {
  [07:09:12.668]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:09:12.668]                 windows = "NUL", "/dev/null"), open = "w")
  [07:09:12.668]         }
  [07:09:12.668]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:09:12.668]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:09:12.668]             base::sink(type = "output", split = FALSE)
  [07:09:12.668]             base::close(...future.stdout)
  [07:09:12.668]         }, add = TRUE)
  [07:09:12.668]     }
  [07:09:12.668]     ...future.frame <- base::sys.nframe()
  [07:09:12.668]     ...future.conditions <- base::list()
  [07:09:12.668]     ...future.rng <- base::globalenv()$.Random.seed
  [07:09:12.668]     ...future.result <- base::tryCatch({
  [07:09:12.668]         base::withCallingHandlers({
  [07:09:12.668]             ...future.value <- base::withVisible(base::local({
  [07:09:12.668]                 sum(x, ...)
  [07:09:12.668]             }))
  [07:09:12.668]             future::FutureResult(value = ...future.value$value, 
  [07:09:12.668]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:09:12.668]                   ...future.rng), started = ...future.startTime, 
  [07:09:12.668]                 version = "1.8")
  [07:09:12.668]         }, condition = base::local({
  [07:09:12.668]             c <- base::c
  [07:09:12.668]             inherits <- base::inherits
  [07:09:12.668]             invokeRestart <- base::invokeRestart
  [07:09:12.668]             length <- base::length
  [07:09:12.668]             list <- base::list
  [07:09:12.668]             seq.int <- base::seq.int
  [07:09:12.668]             signalCondition <- base::signalCondition
  [07:09:12.668]             sys.calls <- base::sys.calls
  [07:09:12.668]             Sys.time <- base::Sys.time
  [07:09:12.668]             `[[` <- base::`[[`
  [07:09:12.668]             `+` <- base::`+`
  [07:09:12.668]             `<<-` <- base::`<<-`
  [07:09:12.668]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:09:12.668]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:09:12.668]                   3L)]
  [07:09:12.668]             }
  [07:09:12.668]             function(cond) {
  [07:09:12.668]                 if (inherits(cond, "error")) {
  [07:09:12.668]                   sessionInformation <- function() {
  [07:09:12.668]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:09:12.668]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:09:12.668]                       search = base::search(), system = base::Sys.info())
  [07:09:12.668]                   }
  [07:09:12.668]                   ...future.conditions[[length(...future.conditions) + 
  [07:09:12.668]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:09:12.668]                     cond$call), session = sessionInformation(), 
  [07:09:12.668]                     timestamp = Sys.time(), signaled = 0L)
  [07:09:12.668]                   signalCondition(cond)
  [07:09:12.668]                 }
  [07:09:12.668]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:09:12.668]                 ))) {
  [07:09:12.668]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:09:12.668]                   ...future.conditions[[length(...future.conditions) + 
  [07:09:12.668]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:09:12.668]                   if (!signal) {
  [07:09:12.668]                     muffleCondition <- function (cond) 
  [07:09:12.668]                     {
  [07:09:12.668]                       inherits <- base::inherits
  [07:09:12.668]                       invokeRestart <- base::invokeRestart
  [07:09:12.668]                       muffled <- FALSE
  [07:09:12.668]                       if (inherits(cond, "message")) {
  [07:09:12.668]                         invokeRestart("muffleMessage")
  [07:09:12.668]                         muffled <- TRUE
  [07:09:12.668]                       }
  [07:09:12.668]                       else if (inherits(cond, "warning")) {
  [07:09:12.668]                         invokeRestart("muffleWarning")
  [07:09:12.668]                         muffled <- TRUE
  [07:09:12.668]                       }
  [07:09:12.668]                       else if (inherits(cond, "condition")) {
  [07:09:12.668]                         computeRestarts <- base::computeRestarts
  [07:09:12.668]                         grepl <- base::grepl
  [07:09:12.668]                         is.null <- base::is.null
  [07:09:12.668]                         restarts <- computeRestarts(cond)
  [07:09:12.668]                         for (restart in restarts) {
  [07:09:12.668]                           name <- restart$name
  [07:09:12.668]                           if (is.null(name)) 
  [07:09:12.668]                             next
  [07:09:12.668]                           if (!grepl("^muffle", name)) 
  [07:09:12.668]                             next
  [07:09:12.668]                           invokeRestart(restart)
  [07:09:12.668]                           muffled <- TRUE
  [07:09:12.668]                           break
  [07:09:12.668]                         }
  [07:09:12.668]                       }
  [07:09:12.668]                       invisible(muffled)
  [07:09:12.668]                     }
  [07:09:12.668]                     muffleCondition(cond)
  [07:09:12.668]                   }
  [07:09:12.668]                 }
  [07:09:12.668]             }
  [07:09:12.668]         }))
  [07:09:12.668]     }, error = function(ex) {
  [07:09:12.668]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:09:12.668]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:09:12.668]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:09:12.668]     }, finally = {
  [07:09:12.668]         {
  [07:09:12.668]             NULL
  [07:09:12.668]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:09:12.668]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:09:12.668]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:09:12.668]                 label = NULL, ...) 
  [07:09:12.668]             {
  [07:09:12.668]                 if (substitute) 
  [07:09:12.668]                   expr <- substitute(expr)
  [07:09:12.668]                 local <- as.logical(local)
  [07:09:12.668]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:09:12.668]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:09:12.668]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:09:12.668]                   label = label, ...)
  [07:09:12.668]                 if (!future$lazy) 
  [07:09:12.668]                   future <- run(future)
  [07:09:12.668]                 invisible(future)
  [07:09:12.668]             }), .cleanup = FALSE, .init = FALSE)
  [07:09:12.668]         }
  [07:09:12.668]         base::options(...future.oldOptions)
  [07:09:12.668]     })
  [07:09:12.668]     Sys.time
  [07:09:12.668]     if (base::is.na(TRUE)) {
  [07:09:12.668]     }
  [07:09:12.668]     else {
  [07:09:12.668]         base::sink(type = "output", split = FALSE)
  [07:09:12.668]         if (TRUE) {
  [07:09:12.668]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:09:12.668]         }
  [07:09:12.668]         else {
  [07:09:12.668]             ...future.result["stdout"] <- base::list(NULL)
  [07:09:12.668]         }
  [07:09:12.668]         base::close(...future.stdout)
  [07:09:12.668]         ...future.stdout <- NULL
  [07:09:12.668]     }
  [07:09:12.668]     ...future.result$conditions <- ...future.conditions
  [07:09:12.668]     ...future.result
  [07:09:12.668] }
  [07:09:12.672] plan(): Setting new future strategy stack:
  [07:09:12.673] List of future strategies:
  [07:09:12.673] 1. sequential:
  [07:09:12.673]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.673]    - tweaked: FALSE
  [07:09:12.673]    - call: NULL
  [07:09:12.673] plan(): nbrOfWorkers() = 1
  [07:09:12.674] plan(): Setting new future strategy stack:
  [07:09:12.675] List of future strategies:
  [07:09:12.675] 1. sequential:
  [07:09:12.675]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.675]    - tweaked: FALSE
  [07:09:12.675]    - call: plan(strategy, substitute = FALSE)
  [07:09:12.676] plan(): nbrOfWorkers() = 1
  [07:09:12.676] 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: 0x2a98a90>
  Arguments '...' exists: FALSE
  [07:09:12.678] getGlobalsAndPackages() ...
  [07:09:12.678] Searching for globals...
  [07:09:12.680] - globals found: [4] '{', 'sum', 'x', 'y'
  [07:09:12.680] Searching for globals ... DONE
  [07:09:12.681] Resolving globals: FALSE
  [07:09:12.682] The total size of the 2 globals is 112 bytes (112 bytes)
  [07:09:12.682] - globals: [2] 'x', 'y'
  [07:09:12.682] 
  [07:09:12.683] getGlobalsAndPackages() ... DONE
  [07:09:12.684] Packages needed by the future expression (n = 0): <none>
  [07:09:12.684] Packages needed by future strategies (n = 0): <none>
  [07:09:12.688] {
  [07:09:12.688]     {
  [07:09:12.688]         ...future.startTime <- base::Sys.time()
  [07:09:12.688]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:09:12.688]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:09:12.688]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:09:12.688]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:09:12.688]             future.resolve.recursive = NULL, width = 80L)
  [07:09:12.688]         {
  [07:09:12.688]             {
  [07:09:12.688]                 base::local({
  [07:09:12.688]                   has_future <- base::requireNamespace("future", 
  [07:09:12.688]                     quietly = TRUE)
  [07:09:12.688]                   version <- if (has_future) 
  [07:09:12.688]                     utils::packageVersion("future")
  [07:09:12.688]                   else NULL
  [07:09:12.688]                   if (!has_future || version < "1.8.0") {
  [07:09:12.688]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:09:12.688]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:09:12.688]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:09:12.688]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:09:12.688]                         "release", "version")], collapse = " "), 
  [07:09:12.688]                       hostname = base::Sys.info()[["nodename"]])
  [07:09:12.688]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:09:12.688]                       info)
  [07:09:12.688]                     info <- base::paste(info, collapse = "; ")
  [07:09:12.688]                     if (!has_future) {
  [07:09:12.688]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:09:12.688]                         info)
  [07:09:12.688]                     }
  [07:09:12.688]                     else {
  [07:09:12.688]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:09:12.688]                         info, version)
  [07:09:12.688]                     }
  [07:09:12.688]                     base::stop(msg)
  [07:09:12.688]                   }
  [07:09:12.688]                 })
  [07:09:12.688]             }
  [07:09:12.688]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:09:12.688]         }
  [07:09:12.688]     }
  [07:09:12.688]     if (base::is.na(TRUE)) {
  [07:09:12.688]     }
  [07:09:12.688]     else {
  [07:09:12.688]         if (TRUE) {
  [07:09:12.688]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:09:12.688]                 open = "w")
  [07:09:12.688]         }
  [07:09:12.688]         else {
  [07:09:12.688]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:09:12.688]                 windows = "NUL", "/dev/null"), open = "w")
  [07:09:12.688]         }
  [07:09:12.688]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:09:12.688]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:09:12.688]             base::sink(type = "output", split = FALSE)
  [07:09:12.688]             base::close(...future.stdout)
  [07:09:12.688]         }, add = TRUE)
  [07:09:12.688]     }
  [07:09:12.688]     ...future.frame <- base::sys.nframe()
  [07:09:12.688]     ...future.conditions <- base::list()
  [07:09:12.688]     ...future.rng <- base::globalenv()$.Random.seed
  [07:09:12.688]     ...future.result <- base::tryCatch({
  [07:09:12.688]         base::withCallingHandlers({
  [07:09:12.688]             ...future.value <- base::withVisible(base::local({
  [07:09:12.688]                 sum(x, y)
  [07:09:12.688]             }))
  [07:09:12.688]             future::FutureResult(value = ...future.value$value, 
  [07:09:12.688]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:09:12.688]                   ...future.rng), started = ...future.startTime, 
  [07:09:12.688]                 version = "1.8")
  [07:09:12.688]         }, condition = base::local({
  [07:09:12.688]             c <- base::c
  [07:09:12.688]             inherits <- base::inherits
  [07:09:12.688]             invokeRestart <- base::invokeRestart
  [07:09:12.688]             length <- base::length
  [07:09:12.688]             list <- base::list
  [07:09:12.688]             seq.int <- base::seq.int
  [07:09:12.688]             signalCondition <- base::signalCondition
  [07:09:12.688]             sys.calls <- base::sys.calls
  [07:09:12.688]             Sys.time <- base::Sys.time
  [07:09:12.688]             `[[` <- base::`[[`
  [07:09:12.688]             `+` <- base::`+`
  [07:09:12.688]             `<<-` <- base::`<<-`
  [07:09:12.688]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:09:12.688]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:09:12.688]                   3L)]
  [07:09:12.688]             }
  [07:09:12.688]             function(cond) {
  [07:09:12.688]                 if (inherits(cond, "error")) {
  [07:09:12.688]                   sessionInformation <- function() {
  [07:09:12.688]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:09:12.688]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:09:12.688]                       search = base::search(), system = base::Sys.info())
  [07:09:12.688]                   }
  [07:09:12.688]                   ...future.conditions[[length(...future.conditions) + 
  [07:09:12.688]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:09:12.688]                     cond$call), session = sessionInformation(), 
  [07:09:12.688]                     timestamp = Sys.time(), signaled = 0L)
  [07:09:12.688]                   signalCondition(cond)
  [07:09:12.688]                 }
  [07:09:12.688]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:09:12.688]                 ))) {
  [07:09:12.688]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:09:12.688]                   ...future.conditions[[length(...future.conditions) + 
  [07:09:12.688]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:09:12.688]                   if (!signal) {
  [07:09:12.688]                     muffleCondition <- function (cond) 
  [07:09:12.688]                     {
  [07:09:12.688]                       inherits <- base::inherits
  [07:09:12.688]                       invokeRestart <- base::invokeRestart
  [07:09:12.688]                       muffled <- FALSE
  [07:09:12.688]                       if (inherits(cond, "message")) {
  [07:09:12.688]                         invokeRestart("muffleMessage")
  [07:09:12.688]                         muffled <- TRUE
  [07:09:12.688]                       }
  [07:09:12.688]                       else if (inherits(cond, "warning")) {
  [07:09:12.688]                         invokeRestart("muffleWarning")
  [07:09:12.688]                         muffled <- TRUE
  [07:09:12.688]                       }
  [07:09:12.688]                       else if (inherits(cond, "condition")) {
  [07:09:12.688]                         computeRestarts <- base::computeRestarts
  [07:09:12.688]                         grepl <- base::grepl
  [07:09:12.688]                         is.null <- base::is.null
  [07:09:12.688]                         restarts <- computeRestarts(cond)
  [07:09:12.688]                         for (restart in restarts) {
  [07:09:12.688]                           name <- restart$name
  [07:09:12.688]                           if (is.null(name)) 
  [07:09:12.688]                             next
  [07:09:12.688]                           if (!grepl("^muffle", name)) 
  [07:09:12.688]                             next
  [07:09:12.688]                           invokeRestart(restart)
  [07:09:12.688]                           muffled <- TRUE
  [07:09:12.688]                           break
  [07:09:12.688]                         }
  [07:09:12.688]                       }
  [07:09:12.688]                       invisible(muffled)
  [07:09:12.688]                     }
  [07:09:12.688]                     muffleCondition(cond)
  [07:09:12.688]                   }
  [07:09:12.688]                 }
  [07:09:12.688]             }
  [07:09:12.688]         }))
  [07:09:12.688]     }, error = function(ex) {
  [07:09:12.688]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:09:12.688]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:09:12.688]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:09:12.688]     }, finally = {
  [07:09:12.688]         {
  [07:09:12.688]             NULL
  [07:09:12.688]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:09:12.688]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:09:12.688]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:09:12.688]                 label = NULL, ...) 
  [07:09:12.688]             {
  [07:09:12.688]                 if (substitute) 
  [07:09:12.688]                   expr <- substitute(expr)
  [07:09:12.688]                 local <- as.logical(local)
  [07:09:12.688]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:09:12.688]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:09:12.688]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:09:12.688]                   label = label, ...)
  [07:09:12.688]                 if (!future$lazy) 
  [07:09:12.688]                   future <- run(future)
  [07:09:12.688]                 invisible(future)
  [07:09:12.688]             }), .cleanup = FALSE, .init = FALSE)
  [07:09:12.688]         }
  [07:09:12.688]         base::options(...future.oldOptions)
  [07:09:12.688]     })
  [07:09:12.688]     Sys.time
  [07:09:12.688]     if (base::is.na(TRUE)) {
  [07:09:12.688]     }
  [07:09:12.688]     else {
  [07:09:12.688]         base::sink(type = "output", split = FALSE)
  [07:09:12.688]         if (TRUE) {
  [07:09:12.688]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:09:12.688]         }
  [07:09:12.688]         else {
  [07:09:12.688]             ...future.result["stdout"] <- base::list(NULL)
  [07:09:12.688]         }
  [07:09:12.688]         base::close(...future.stdout)
  [07:09:12.688]         ...future.stdout <- NULL
  [07:09:12.688]     }
  [07:09:12.688]     ...future.result$conditions <- ...future.conditions
  [07:09:12.688]     ...future.result
  [07:09:12.688] }
  [07:09:12.693] plan(): Setting new future strategy stack:
  [07:09:12.693] List of future strategies:
  [07:09:12.693] 1. sequential:
  [07:09:12.693]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.693]    - tweaked: FALSE
  [07:09:12.693]    - call: NULL
  [07:09:12.694] plan(): nbrOfWorkers() = 1
  [07:09:12.695] plan(): Setting new future strategy stack:
  [07:09:12.695] List of future strategies:
  [07:09:12.695] 1. sequential:
  [07:09:12.695]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.695]    - tweaked: FALSE
  [07:09:12.695]    - call: plan(strategy, substitute = FALSE)
  [07:09:12.696] plan(): nbrOfWorkers() = 1
  [07:09:12.697] 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: 0x21e1928>
  Arguments '...' exists: FALSE
  [07:09:12.698] getGlobalsAndPackages() ...
  [07:09:12.699] Searching for globals...
  [07:09:12.701] - globals found: [5] '{', 'sum', 'x', 'y', '...'
  [07:09:12.702] Searching for globals ... DONE
  [07:09:12.702] Resolving globals: FALSE
  [07:09:12.702] Tweak future expression to call with '...' arguments ...
  [07:09:12.703] 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') ...
  [07:09:12.715] plan(): Setting new future strategy stack:
  [07:09:12.715] List of future strategies:
  [07:09:12.715] 1. multicore:
  [07:09:12.715]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:09:12.715]    - tweaked: FALSE
  [07:09:12.715]    - call: plan(strategy, substitute = FALSE)
  [07:09:12.717] plan(): nbrOfWorkers() = 2
  ** Sum function 'A' with plan('multicore') ...
  function (x, ...) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, ...)
      }
      y
  }
  <bytecode: 0x3bd9290>
  Arguments '...' exists: TRUE
  [07:09:12.718] getGlobalsAndPackages() ...
  [07:09:12.718] Searching for globals...
  [07:09:12.721] - globals found: [4] '{', 'sum', 'x', '...'
  [07:09:12.721] Searching for globals ... DONE
  [07:09:12.721] Resolving globals: FALSE
  [07:09:12.722] Tweak future expression to call with '...' arguments ...
  [07:09:12.722] Tweak future expression to call with '...' arguments ... DONE
  [07:09:12.723] The total size of the 2 globals is 112 bytes (112 bytes)
  [07:09:12.723] - globals: [2] 'x', 'future.call.arguments'
  [07:09:12.724] 
  [07:09:12.724] getGlobalsAndPackages() ... DONE
  [07:09:12.726] Packages needed by the future expression (n = 0): <none>
  [07:09:12.727] Packages needed by future strategies (n = 0): <none>
  [07:09:12.730] {
  [07:09:12.730]     {
  [07:09:12.730]         ...future.startTime <- base::Sys.time()
  [07:09:12.730]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:09:12.730]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:09:12.730]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:09:12.730]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:09:12.730]             future.resolve.recursive = NULL, width = 80L)
  [07:09:12.730]         {
  [07:09:12.730]             {
  [07:09:12.730]                 {
  [07:09:12.730]                   base::local({
  [07:09:12.730]                     has_future <- base::requireNamespace("future", 
  [07:09:12.730]                       quietly = TRUE)
  [07:09:12.730]                     version <- if (has_future) 
  [07:09:12.730]                       utils::packageVersion("future")
  [07:09:12.730]                     else NULL
  [07:09:12.730]                     if (!has_future || version < "1.8.0") {
  [07:09:12.730]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:09:12.730]                         "", base::R.version$version.string), 
  [07:09:12.730]                         platform = base::sprintf("%s (%s-bit)", 
  [07:09:12.730]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:09:12.730]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:09:12.730]                           "release", "version")], collapse = " "), 
  [07:09:12.730]                         hostname = base::Sys.info()[["nodename"]])
  [07:09:12.730]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:09:12.730]                         info)
  [07:09:12.730]                       info <- base::paste(info, collapse = "; ")
  [07:09:12.730]                       if (!has_future) {
  [07:09:12.730]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:09:12.730]                           info)
  [07:09:12.730]                       }
  [07:09:12.730]                       else {
  [07:09:12.730]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:09:12.730]                           info, version)
  [07:09:12.730]                       }
  [07:09:12.730]                       base::stop(msg)
  [07:09:12.730]                     }
  [07:09:12.730]                   })
  [07:09:12.730]                 }
  [07:09:12.730]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:09:12.730]                 base::options(mc.cores = 1L)
  [07:09:12.730]             }
  [07:09:12.730]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:09:12.730]         }
  [07:09:12.730]     }
  [07:09:12.730]     if (base::is.na(TRUE)) {
  [07:09:12.730]     }
  [07:09:12.730]     else {
  [07:09:12.730]         if (TRUE) {
  [07:09:12.730]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:09:12.730]                 open = "w")
  [07:09:12.730]         }
  [07:09:12.730]         else {
  [07:09:12.730]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:09:12.730]                 windows = "NUL", "/dev/null"), open = "w")
  [07:09:12.730]         }
  [07:09:12.730]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:09:12.730]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:09:12.730]             base::sink(type = "output", split = FALSE)
  [07:09:12.730]             base::close(...future.stdout)
  [07:09:12.730]         }, add = TRUE)
  [07:09:12.730]     }
  [07:09:12.730]     ...future.frame <- base::sys.nframe()
  [07:09:12.730]     ...future.conditions <- base::list()
  [07:09:12.730]     ...future.rng <- base::globalenv()$.Random.seed
  [07:09:12.730]     ...future.result <- base::tryCatch({
  [07:09:12.730]         base::withCallingHandlers({
  [07:09:12.730]             ...future.value <- base::withVisible(base::local({
  [07:09:12.730]                 sum(x, ...)
  [07:09:12.730]             }))
  [07:09:12.730]             future::FutureResult(value = ...future.value$value, 
  [07:09:12.730]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:09:12.730]                   ...future.rng), started = ...future.startTime, 
  [07:09:12.730]                 version = "1.8")
  [07:09:12.730]         }, condition = base::local({
  [07:09:12.730]             c <- base::c
  [07:09:12.730]             inherits <- base::inherits
  [07:09:12.730]             invokeRestart <- base::invokeRestart
  [07:09:12.730]             length <- base::length
  [07:09:12.730]             list <- base::list
  [07:09:12.730]             seq.int <- base::seq.int
  [07:09:12.730]             signalCondition <- base::signalCondition
  [07:09:12.730]             sys.calls <- base::sys.calls
  [07:09:12.730]             Sys.time <- base::Sys.time
  [07:09:12.730]             `[[` <- base::`[[`
  [07:09:12.730]             `+` <- base::`+`
  [07:09:12.730]             `<<-` <- base::`<<-`
  [07:09:12.730]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:09:12.730]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:09:12.730]                   3L)]
  [07:09:12.730]             }
  [07:09:12.730]             function(cond) {
  [07:09:12.730]                 if (inherits(cond, "error")) {
  [07:09:12.730]                   sessionInformation <- function() {
  [07:09:12.730]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:09:12.730]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:09:12.730]                       search = base::search(), system = base::Sys.info())
  [07:09:12.730]                   }
  [07:09:12.730]                   ...future.conditions[[length(...future.conditions) + 
  [07:09:12.730]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:09:12.730]                     cond$call), session = sessionInformation(), 
  [07:09:12.730]                     timestamp = Sys.time(), signaled = 0L)
  [07:09:12.730]                   signalCondition(cond)
  [07:09:12.730]                 }
  [07:09:12.730]                 else if (inherits(cond, "condition")) {
  [07:09:12.730]                   signal <- FALSE && inherits(cond, character(0))
  [07:09:12.730]                   ...future.conditions[[length(...future.conditions) + 
  [07:09:12.730]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:09:12.730]                   if (!signal) {
  [07:09:12.730]                     muffleCondition <- function (cond) 
  [07:09:12.730]                     {
  [07:09:12.730]                       inherits <- base::inherits
  [07:09:12.730]                       invokeRestart <- base::invokeRestart
  [07:09:12.730]                       muffled <- FALSE
  [07:09:12.730]                       if (inherits(cond, "message")) {
  [07:09:12.730]                         invokeRestart("muffleMessage")
  [07:09:12.730]                         muffled <- TRUE
  [07:09:12.730]                       }
  [07:09:12.730]                       else if (inherits(cond, "warning")) {
  [07:09:12.730]                         invokeRestart("muffleWarning")
  [07:09:12.730]                         muffled <- TRUE
  [07:09:12.730]                       }
  [07:09:12.730]                       else if (inherits(cond, "condition")) {
  [07:09:12.730]                         computeRestarts <- base::computeRestarts
  [07:09:12.730]                         grepl <- base::grepl
  [07:09:12.730]                         is.null <- base::is.null
  [07:09:12.730]                         restarts <- computeRestarts(cond)
  [07:09:12.730]                         for (restart in restarts) {
  [07:09:12.730]                           name <- restart$name
  [07:09:12.730]                           if (is.null(name)) 
  [07:09:12.730]                             next
  [07:09:12.730]                           if (!grepl("^muffle", name)) 
  [07:09:12.730]                             next
  [07:09:12.730]                           invokeRestart(restart)
  [07:09:12.730]                           muffled <- TRUE
  [07:09:12.730]                           break
  [07:09:12.730]                         }
  [07:09:12.730]                       }
  [07:09:12.730]                       invisible(muffled)
  [07:09:12.730]                     }
  [07:09:12.730]                     muffleCondition(cond)
  [07:09:12.730]                   }
  [07:09:12.730]                 }
  [07:09:12.730]             }
  [07:09:12.730]         }))
  [07:09:12.730]     }, error = function(ex) {
  [07:09:12.730]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:09:12.730]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:09:12.730]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:09:12.730]     }, finally = {
  [07:09:12.730]         {
  [07:09:12.730]             {
  [07:09:12.730]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:09:12.730]             }
  [07:09:12.730]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:09:12.730]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:09:12.730]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:09:12.730]                 earlySignal = FALSE, label = NULL, ...) 
  [07:09:12.730]             {
  [07:09:12.730]                 if (substitute) 
  [07:09:12.730]                   expr <- substitute(expr)
  [07:09:12.730]                 if (is.function(workers)) 
  [07:09:12.730]                   workers <- workers()
  [07:09:12.730]                 workers <- as.integer(workers)
  [07:09:12.730]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:09:12.730]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:09:12.730]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:09:12.730]                     lazy = lazy, seed = seed, globals = globals, 
  [07:09:12.730]                     local = TRUE, label = label, ...))
  [07:09:12.730]                 }
  [07:09:12.730]                 oopts <- options(mc.cores = workers)
  [07:09:12.730]                 on.exit(options(oopts))
  [07:09:12.730]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:09:12.730]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:09:12.730]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:09:12.730]                   label = label, ...)
  [07:09:12.730]                 if (!future$lazy) 
  [07:09:12.730]                   future <- run(future)
  [07:09:12.730]                 invisible(future)
  [07:09:12.730]             }), .cleanup = FALSE, .init = FALSE)
  [07:09:12.730]         }
  [07:09:12.730]         base::options(...future.oldOptions)
  [07:09:12.730]     })
  [07:09:12.730]     Sys.time
  [07:09:12.730]     if (base::is.na(TRUE)) {
  [07:09:12.730]     }
  [07:09:12.730]     else {
  [07:09:12.730]         base::sink(type = "output", split = FALSE)
  [07:09:12.730]         if (TRUE) {
  [07:09:12.730]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:09:12.730]         }
  [07:09:12.730]         else {
  [07:09:12.730]             ...future.result["stdout"] <- base::list(NULL)
  [07:09:12.730]         }
  [07:09:12.730]         base::close(...future.stdout)
  [07:09:12.730]         ...future.stdout <- NULL
  [07:09:12.730]     }
  [07:09:12.730]     ...future.result$conditions <- ...future.conditions
  [07:09:12.730]     ...future.result
  [07:09:12.730] }
  [07:09:12.734] requestCore(): workers = 2
  [07:09:12.741] MulticoreFuture started
  [07:09:12.746] plan(): Setting new future strategy stack:
  [07:09:12.747] List of future strategies:
  [07:09:12.747] 1. sequential:
  [07:09:12.747]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.747]    - tweaked: FALSE
  [07:09:12.747]    - call: NULL
  [07:09:12.749] plan(): nbrOfWorkers() = 1
  [07:09:12.751] plan(): Setting new future strategy stack:
  [07:09:12.751] List of future strategies:
  [07:09:12.751] 1. multicore:
  [07:09:12.751]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:09:12.751]    - tweaked: FALSE
  [07:09:12.751]    - call: plan(strategy, substitute = FALSE)
  [07:09:12.753] 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: 0x4082648>
  Arguments '...' exists: TRUE
  [07:09:12.764] getGlobalsAndPackages() ...
  [07:09:12.765] Searching for globals...
  [07:09:12.768] - globals found: [4] '{', 'sum', 'x', '...'
  [07:09:12.768] Searching for globals ... DONE
  [07:09:12.769] Resolving globals: FALSE
  [07:09:12.769] Tweak future expression to call with '...' arguments ...
  [07:09:12.770] Tweak future expression to call with '...' arguments ... DONE
  [07:09:12.771] The total size of the 2 globals is 112 bytes (112 bytes)
  [07:09:12.771] - globals: [2] 'x', 'future.call.arguments'
  [07:09:12.772] 
  [07:09:12.772] getGlobalsAndPackages() ... DONE
  [07:09:12.774] Packages needed by the future expression (n = 0): <none>
  [07:09:12.775] Packages needed by future strategies (n = 0): <none>
  [07:09:12.779] {
  [07:09:12.779]     {
  [07:09:12.779]         ...future.startTime <- base::Sys.time()
  [07:09:12.779]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:09:12.779]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:09:12.779]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:09:12.779]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:09:12.779]             future.resolve.recursive = NULL, width = 80L)
  [07:09:12.779]         {
  [07:09:12.779]             {
  [07:09:12.779]                 {
  [07:09:12.779]                   base::local({
  [07:09:12.779]                     has_future <- base::requireNamespace("future", 
  [07:09:12.779]                       quietly = TRUE)
  [07:09:12.779]                     version <- if (has_future) 
  [07:09:12.779]                       utils::packageVersion("future")
  [07:09:12.779]                     else NULL
  [07:09:12.779]                     if (!has_future || version < "1.8.0") {
  [07:09:12.779]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:09:12.779]                         "", base::R.version$version.string), 
  [07:09:12.779]                         platform = base::sprintf("%s (%s-bit)", 
  [07:09:12.779]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:09:12.779]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:09:12.779]                           "release", "version")], collapse = " "), 
  [07:09:12.779]                         hostname = base::Sys.info()[["nodename"]])
  [07:09:12.779]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:09:12.779]                         info)
  [07:09:12.779]                       info <- base::paste(info, collapse = "; ")
  [07:09:12.779]                       if (!has_future) {
  [07:09:12.779]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:09:12.779]                           info)
  [07:09:12.779]                       }
  [07:09:12.779]                       else {
  [07:09:12.779]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:09:12.779]                           info, version)
  [07:09:12.779]                       }
  [07:09:12.779]                       base::stop(msg)
  [07:09:12.779]                     }
  [07:09:12.779]                   })
  [07:09:12.779]                 }
  [07:09:12.779]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:09:12.779]                 base::options(mc.cores = 1L)
  [07:09:12.779]             }
  [07:09:12.779]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:09:12.779]         }
  [07:09:12.779]     }
  [07:09:12.779]     if (base::is.na(TRUE)) {
  [07:09:12.779]     }
  [07:09:12.779]     else {
  [07:09:12.779]         if (TRUE) {
  [07:09:12.779]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:09:12.779]                 open = "w")
  [07:09:12.779]         }
  [07:09:12.779]         else {
  [07:09:12.779]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:09:12.779]                 windows = "NUL", "/dev/null"), open = "w")
  [07:09:12.779]         }
  [07:09:12.779]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:09:12.779]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:09:12.779]             base::sink(type = "output", split = FALSE)
  [07:09:12.779]             base::close(...future.stdout)
  [07:09:12.779]         }, add = TRUE)
  [07:09:12.779]     }
  [07:09:12.779]     ...future.frame <- base::sys.nframe()
  [07:09:12.779]     ...future.conditions <- base::list()
  [07:09:12.779]     ...future.rng <- base::globalenv()$.Random.seed
  [07:09:12.779]     ...future.result <- base::tryCatch({
  [07:09:12.779]         base::withCallingHandlers({
  [07:09:12.779]             ...future.value <- base::withVisible(base::local({
  [07:09:12.779]                 sum(x, ...)
  [07:09:12.779]             }))
  [07:09:12.779]             future::FutureResult(value = ...future.value$value, 
  [07:09:12.779]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:09:12.779]                   ...future.rng), started = ...future.startTime, 
  [07:09:12.779]                 version = "1.8")
  [07:09:12.779]         }, condition = base::local({
  [07:09:12.779]             c <- base::c
  [07:09:12.779]             inherits <- base::inherits
  [07:09:12.779]             invokeRestart <- base::invokeRestart
  [07:09:12.779]             length <- base::length
  [07:09:12.779]             list <- base::list
  [07:09:12.779]             seq.int <- base::seq.int
  [07:09:12.779]             signalCondition <- base::signalCondition
  [07:09:12.779]             sys.calls <- base::sys.calls
  [07:09:12.779]             Sys.time <- base::Sys.time
  [07:09:12.779]             `[[` <- base::`[[`
  [07:09:12.779]             `+` <- base::`+`
  [07:09:12.779]             `<<-` <- base::`<<-`
  [07:09:12.779]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:09:12.779]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:09:12.779]                   3L)]
  [07:09:12.779]             }
  [07:09:12.779]             function(cond) {
  [07:09:12.779]                 if (inherits(cond, "error")) {
  [07:09:12.779]                   sessionInformation <- function() {
  [07:09:12.779]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:09:12.779]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:09:12.779]                       search = base::search(), system = base::Sys.info())
  [07:09:12.779]                   }
  [07:09:12.779]                   ...future.conditions[[length(...future.conditions) + 
  [07:09:12.779]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:09:12.779]                     cond$call), session = sessionInformation(), 
  [07:09:12.779]                     timestamp = Sys.time(), signaled = 0L)
  [07:09:12.779]                   signalCondition(cond)
  [07:09:12.779]                 }
  [07:09:12.779]                 else if (inherits(cond, "condition")) {
  [07:09:12.779]                   signal <- FALSE && inherits(cond, character(0))
  [07:09:12.779]                   ...future.conditions[[length(...future.conditions) + 
  [07:09:12.779]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:09:12.779]                   if (!signal) {
  [07:09:12.779]                     muffleCondition <- function (cond) 
  [07:09:12.779]                     {
  [07:09:12.779]                       inherits <- base::inherits
  [07:09:12.779]                       invokeRestart <- base::invokeRestart
  [07:09:12.779]                       muffled <- FALSE
  [07:09:12.779]                       if (inherits(cond, "message")) {
  [07:09:12.779]                         invokeRestart("muffleMessage")
  [07:09:12.779]                         muffled <- TRUE
  [07:09:12.779]                       }
  [07:09:12.779]                       else if (inherits(cond, "warning")) {
  [07:09:12.779]                         invokeRestart("muffleWarning")
  [07:09:12.779]                         muffled <- TRUE
  [07:09:12.779]                       }
  [07:09:12.779]                       else if (inherits(cond, "condition")) {
  [07:09:12.779]                         computeRestarts <- base::computeRestarts
  [07:09:12.779]                         grepl <- base::grepl
  [07:09:12.779]                         is.null <- base::is.null
  [07:09:12.779]                         restarts <- computeRestarts(cond)
  [07:09:12.779]                         for (restart in restarts) {
  [07:09:12.779]                           name <- restart$name
  [07:09:12.779]                           if (is.null(name)) 
  [07:09:12.779]                             next
  [07:09:12.779]                           if (!grepl("^muffle", name)) 
  [07:09:12.779]                             next
  [07:09:12.779]                           invokeRestart(restart)
  [07:09:12.779]                           muffled <- TRUE
  [07:09:12.779]                           break
  [07:09:12.779]                         }
  [07:09:12.779]                       }
  [07:09:12.779]                       invisible(muffled)
  [07:09:12.779]                     }
  [07:09:12.779]                     muffleCondition(cond)
  [07:09:12.779]                   }
  [07:09:12.779]                 }
  [07:09:12.779]             }
  [07:09:12.779]         }))
  [07:09:12.779]     }, error = function(ex) {
  [07:09:12.779]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:09:12.779]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:09:12.779]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:09:12.779]     }, finally = {
  [07:09:12.779]         {
  [07:09:12.779]             {
  [07:09:12.779]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:09:12.779]             }
  [07:09:12.779]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:09:12.779]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:09:12.779]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:09:12.779]                 earlySignal = FALSE, label = NULL, ...) 
  [07:09:12.779]             {
  [07:09:12.779]                 if (substitute) 
  [07:09:12.779]                   expr <- substitute(expr)
  [07:09:12.779]                 if (is.function(workers)) 
  [07:09:12.779]                   workers <- workers()
  [07:09:12.779]                 workers <- as.integer(workers)
  [07:09:12.779]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:09:12.779]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:09:12.779]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:09:12.779]                     lazy = lazy, seed = seed, globals = globals, 
  [07:09:12.779]                     local = TRUE, label = label, ...))
  [07:09:12.779]                 }
  [07:09:12.779]                 oopts <- options(mc.cores = workers)
  [07:09:12.779]                 on.exit(options(oopts))
  [07:09:12.779]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:09:12.779]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:09:12.779]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:09:12.779]                   label = label, ...)
  [07:09:12.779]                 if (!future$lazy) 
  [07:09:12.779]                   future <- run(future)
  [07:09:12.779]                 invisible(future)
  [07:09:12.779]             }), .cleanup = FALSE, .init = FALSE)
  [07:09:12.779]         }
  [07:09:12.779]         base::options(...future.oldOptions)
  [07:09:12.779]     })
  [07:09:12.779]     Sys.time
  [07:09:12.779]     if (base::is.na(TRUE)) {
  [07:09:12.779]     }
  [07:09:12.779]     else {
  [07:09:12.779]         base::sink(type = "output", split = FALSE)
  [07:09:12.779]         if (TRUE) {
  [07:09:12.779]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:09:12.779]         }
  [07:09:12.779]         else {
  [07:09:12.779]             ...future.result["stdout"] <- base::list(NULL)
  [07:09:12.779]         }
  [07:09:12.779]         base::close(...future.stdout)
  [07:09:12.779]         ...future.stdout <- NULL
  [07:09:12.779]     }
  [07:09:12.779]     ...future.result$conditions <- ...future.conditions
  [07:09:12.779]     ...future.result
  [07:09:12.779] }
  [07:09:12.784] requestCore(): workers = 2
  [07:09:12.787] MulticoreFuture started
  [07:09:12.792] plan(): Setting new future strategy stack:
  [07:09:12.793] List of future strategies:
  [07:09:12.793] 1. sequential:
  [07:09:12.793]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.793]    - tweaked: FALSE
  [07:09:12.793]    - call: NULL
  [07:09:12.795] plan(): nbrOfWorkers() = 1
  [07:09:12.796] plan(): Setting new future strategy stack:
  [07:09:12.797] List of future strategies:
  [07:09:12.797] 1. multicore:
  [07:09:12.797]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:09:12.797]    - tweaked: FALSE
  [07:09:12.797]    - call: plan(strategy, substitute = FALSE)
  [07:09:12.799] 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: 0x2a98a90>
  Arguments '...' exists: FALSE
  [07:09:12.804] getGlobalsAndPackages() ...
  [07:09:12.804] Searching for globals...
  [07:09:12.807] - globals found: [4] '{', 'sum', 'x', 'y'
  [07:09:12.807] Searching for globals ... DONE
  [07:09:12.808] Resolving globals: FALSE
  [07:09:12.809] The total size of the 2 globals is 112 bytes (112 bytes)
  [07:09:12.809] - globals: [2] 'x', 'y'
  [07:09:12.810] 
  [07:09:12.810] getGlobalsAndPackages() ... DONE
  [07:09:12.812] Packages needed by the future expression (n = 0): <none>
  [07:09:12.812] Packages needed by future strategies (n = 0): <none>
  [07:09:12.817] {
  [07:09:12.817]     {
  [07:09:12.817]         ...future.startTime <- base::Sys.time()
  [07:09:12.817]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:09:12.817]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:09:12.817]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:09:12.817]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:09:12.817]             future.resolve.recursive = NULL, width = 80L)
  [07:09:12.817]         {
  [07:09:12.817]             {
  [07:09:12.817]                 {
  [07:09:12.817]                   base::local({
  [07:09:12.817]                     has_future <- base::requireNamespace("future", 
  [07:09:12.817]                       quietly = TRUE)
  [07:09:12.817]                     version <- if (has_future) 
  [07:09:12.817]                       utils::packageVersion("future")
  [07:09:12.817]                     else NULL
  [07:09:12.817]                     if (!has_future || version < "1.8.0") {
  [07:09:12.817]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:09:12.817]                         "", base::R.version$version.string), 
  [07:09:12.817]                         platform = base::sprintf("%s (%s-bit)", 
  [07:09:12.817]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:09:12.817]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:09:12.817]                           "release", "version")], collapse = " "), 
  [07:09:12.817]                         hostname = base::Sys.info()[["nodename"]])
  [07:09:12.817]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:09:12.817]                         info)
  [07:09:12.817]                       info <- base::paste(info, collapse = "; ")
  [07:09:12.817]                       if (!has_future) {
  [07:09:12.817]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:09:12.817]                           info)
  [07:09:12.817]                       }
  [07:09:12.817]                       else {
  [07:09:12.817]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:09:12.817]                           info, version)
  [07:09:12.817]                       }
  [07:09:12.817]                       base::stop(msg)
  [07:09:12.817]                     }
  [07:09:12.817]                   })
  [07:09:12.817]                 }
  [07:09:12.817]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:09:12.817]                 base::options(mc.cores = 1L)
  [07:09:12.817]             }
  [07:09:12.817]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:09:12.817]         }
  [07:09:12.817]     }
  [07:09:12.817]     if (base::is.na(TRUE)) {
  [07:09:12.817]     }
  [07:09:12.817]     else {
  [07:09:12.817]         if (TRUE) {
  [07:09:12.817]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:09:12.817]                 open = "w")
  [07:09:12.817]         }
  [07:09:12.817]         else {
  [07:09:12.817]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:09:12.817]                 windows = "NUL", "/dev/null"), open = "w")
  [07:09:12.817]         }
  [07:09:12.817]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:09:12.817]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:09:12.817]             base::sink(type = "output", split = FALSE)
  [07:09:12.817]             base::close(...future.stdout)
  [07:09:12.817]         }, add = TRUE)
  [07:09:12.817]     }
  [07:09:12.817]     ...future.frame <- base::sys.nframe()
  [07:09:12.817]     ...future.conditions <- base::list()
  [07:09:12.817]     ...future.rng <- base::globalenv()$.Random.seed
  [07:09:12.817]     ...future.result <- base::tryCatch({
  [07:09:12.817]         base::withCallingHandlers({
  [07:09:12.817]             ...future.value <- base::withVisible(base::local({
  [07:09:12.817]                 sum(x, y)
  [07:09:12.817]             }))
  [07:09:12.817]             future::FutureResult(value = ...future.value$value, 
  [07:09:12.817]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:09:12.817]                   ...future.rng), started = ...future.startTime, 
  [07:09:12.817]                 version = "1.8")
  [07:09:12.817]         }, condition = base::local({
  [07:09:12.817]             c <- base::c
  [07:09:12.817]             inherits <- base::inherits
  [07:09:12.817]             invokeRestart <- base::invokeRestart
  [07:09:12.817]             length <- base::length
  [07:09:12.817]             list <- base::list
  [07:09:12.817]             seq.int <- base::seq.int
  [07:09:12.817]             signalCondition <- base::signalCondition
  [07:09:12.817]             sys.calls <- base::sys.calls
  [07:09:12.817]             Sys.time <- base::Sys.time
  [07:09:12.817]             `[[` <- base::`[[`
  [07:09:12.817]             `+` <- base::`+`
  [07:09:12.817]             `<<-` <- base::`<<-`
  [07:09:12.817]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:09:12.817]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:09:12.817]                   3L)]
  [07:09:12.817]             }
  [07:09:12.817]             function(cond) {
  [07:09:12.817]                 if (inherits(cond, "error")) {
  [07:09:12.817]                   sessionInformation <- function() {
  [07:09:12.817]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:09:12.817]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:09:12.817]                       search = base::search(), system = base::Sys.info())
  [07:09:12.817]                   }
  [07:09:12.817]                   ...future.conditions[[length(...future.conditions) + 
  [07:09:12.817]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:09:12.817]                     cond$call), session = sessionInformation(), 
  [07:09:12.817]                     timestamp = Sys.time(), signaled = 0L)
  [07:09:12.817]                   signalCondition(cond)
  [07:09:12.817]                 }
  [07:09:12.817]                 else if (inherits(cond, "condition")) {
  [07:09:12.817]                   signal <- FALSE && inherits(cond, character(0))
  [07:09:12.817]                   ...future.conditions[[length(...future.conditions) + 
  [07:09:12.817]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:09:12.817]                   if (!signal) {
  [07:09:12.817]                     muffleCondition <- function (cond) 
  [07:09:12.817]                     {
  [07:09:12.817]                       inherits <- base::inherits
  [07:09:12.817]                       invokeRestart <- base::invokeRestart
  [07:09:12.817]                       muffled <- FALSE
  [07:09:12.817]                       if (inherits(cond, "message")) {
  [07:09:12.817]                         invokeRestart("muffleMessage")
  [07:09:12.817]                         muffled <- TRUE
  [07:09:12.817]                       }
  [07:09:12.817]                       else if (inherits(cond, "warning")) {
  [07:09:12.817]                         invokeRestart("muffleWarning")
  [07:09:12.817]                         muffled <- TRUE
  [07:09:12.817]                       }
  [07:09:12.817]                       else if (inherits(cond, "condition")) {
  [07:09:12.817]                         computeRestarts <- base::computeRestarts
  [07:09:12.817]                         grepl <- base::grepl
  [07:09:12.817]                         is.null <- base::is.null
  [07:09:12.817]                         restarts <- computeRestarts(cond)
  [07:09:12.817]                         for (restart in restarts) {
  [07:09:12.817]                           name <- restart$name
  [07:09:12.817]                           if (is.null(name)) 
  [07:09:12.817]                             next
  [07:09:12.817]                           if (!grepl("^muffle", name)) 
  [07:09:12.817]                             next
  [07:09:12.817]                           invokeRestart(restart)
  [07:09:12.817]                           muffled <- TRUE
  [07:09:12.817]                           break
  [07:09:12.817]                         }
  [07:09:12.817]                       }
  [07:09:12.817]                       invisible(muffled)
  [07:09:12.817]                     }
  [07:09:12.817]                     muffleCondition(cond)
  [07:09:12.817]                   }
  [07:09:12.817]                 }
  [07:09:12.817]             }
  [07:09:12.817]         }))
  [07:09:12.817]     }, error = function(ex) {
  [07:09:12.817]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:09:12.817]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:09:12.817]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:09:12.817]     }, finally = {
  [07:09:12.817]         {
  [07:09:12.817]             {
  [07:09:12.817]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:09:12.817]             }
  [07:09:12.817]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:09:12.817]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:09:12.817]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:09:12.817]                 earlySignal = FALSE, label = NULL, ...) 
  [07:09:12.817]             {
  [07:09:12.817]                 if (substitute) 
  [07:09:12.817]                   expr <- substitute(expr)
  [07:09:12.817]                 if (is.function(workers)) 
  [07:09:12.817]                   workers <- workers()
  [07:09:12.817]                 workers <- as.integer(workers)
  [07:09:12.817]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:09:12.817]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:09:12.817]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:09:12.817]                     lazy = lazy, seed = seed, globals = globals, 
  [07:09:12.817]                     local = TRUE, label = label, ...))
  [07:09:12.817]                 }
  [07:09:12.817]                 oopts <- options(mc.cores = workers)
  [07:09:12.817]                 on.exit(options(oopts))
  [07:09:12.817]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:09:12.817]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:09:12.817]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:09:12.817]                   label = label, ...)
  [07:09:12.817]                 if (!future$lazy) 
  [07:09:12.817]                   future <- run(future)
  [07:09:12.817]                 invisible(future)
  [07:09:12.817]             }), .cleanup = FALSE, .init = FALSE)
  [07:09:12.817]         }
  [07:09:12.817]         base::options(...future.oldOptions)
  [07:09:12.817]     })
  [07:09:12.817]     Sys.time
  [07:09:12.817]     if (base::is.na(TRUE)) {
  [07:09:12.817]     }
  [07:09:12.817]     else {
  [07:09:12.817]         base::sink(type = "output", split = FALSE)
  [07:09:12.817]         if (TRUE) {
  [07:09:12.817]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:09:12.817]         }
  [07:09:12.817]         else {
  [07:09:12.817]             ...future.result["stdout"] <- base::list(NULL)
  [07:09:12.817]         }
  [07:09:12.817]         base::close(...future.stdout)
  [07:09:12.817]         ...future.stdout <- NULL
  [07:09:12.817]     }
  [07:09:12.817]     ...future.result$conditions <- ...future.conditions
  [07:09:12.817]     ...future.result
  [07:09:12.817] }
  [07:09:12.821] requestCore(): workers = 2
  [07:09:12.828] MulticoreFuture started
  [07:09:12.837] plan(): Setting new future strategy stack:
  [07:09:12.839] List of future strategies:
  [07:09:12.839] 1. sequential:
  [07:09:12.839]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.839]    - tweaked: FALSE
  [07:09:12.839]    - call: NULL
  [07:09:12.843] plan(): nbrOfWorkers() = 1
  [07:09:12.847] plan(): Setting new future strategy stack:
  [07:09:12.848] List of future strategies:
  [07:09:12.848] 1. multicore:
  [07:09:12.848]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:09:12.848]    - tweaked: FALSE
  [07:09:12.848]    - call: plan(strategy, substitute = FALSE)
  [07:09:12.853] 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: 0x21e1928>
  Arguments '...' exists: FALSE
  [07:09:12.859] getGlobalsAndPackages() ...
  [07:09:12.860] Searching for globals...
  [07:09:12.865] - globals found: [5] '{', 'sum', 'x', 'y', '...'
  [07:09:12.866] Searching for globals ... DONE
  [07:09:12.867] Resolving globals: FALSE
  [07:09:12.867] Tweak future expression to call with '...' arguments ...
  [07:09:12.868] 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') ...
  [07:09:12.871] plan(): Setting new future strategy stack:
  [07:09:12.871] List of future strategies:
  [07:09:12.871] 1. multisession:
  [07:09:12.871]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.871]    - tweaked: FALSE
  [07:09:12.871]    - call: plan(strategy, substitute = FALSE)
  [07:09:12.873] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [07:09:12.873] multisession:
  [07:09:12.873] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [07:09:12.873] - tweaked: FALSE
  [07:09:12.873] - call: plan(strategy, substitute = FALSE)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 31396
  [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/Rtmpk6JOTc/working_dir/RtmpJndCe9/future.parent=685112.a743810f72d1.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmpk6JOTc/working_dir/RtmpJndCe9/future.parent=685112.a743810f72d1.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:685112' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpk6JOTc/working_dir/RtmpJndCe9/future.parent=685112.a743810f72d1.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=31396 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 685243) if still alive
  [07:11:13.765] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(685112, signal = 0L)
  [1] TRUE
  Call: tools::pskill(685112, signal = 0L)
  [1] TRUE
  [07:11:13.766] - success
  [07:11:13.766] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 685243) 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 31396 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:685112' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpk6JOTc/working_dir/RtmpJndCe9/future.parent=685112.a743810f72d1.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=31396 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 685243) 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")
  [07:11:14.130] plan(): Setting new future strategy stack:
  [07:11:14.131] List of future strategies:
  [07:11:14.131] 1. sequential:
  [07:11:14.131]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:11:14.131]    - tweaked: FALSE
  [07:11:14.131]    - call: future::plan("sequential")
  [07:11:14.132] 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 26349 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:692883' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpk6JOTc/working_dir/Rtmp3lUajN/future.parent=692883.a929358b6eb7.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=26349 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 692950) 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")
  [07:13:16.551] plan(): Setting new future strategy stack:
  [07:13:16.552] List of future strategies:
  [07:13:16.552] 1. sequential:
  [07:13:16.552]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.552]    - tweaked: FALSE
  [07:13:16.552]    - call: future::plan("sequential")
  [07:13:16.554] 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)
  [07:13:16.571] getGlobalsAndPackages() ...
  [07:13:16.571] Searching for globals...
  [07:13:16.579] - globals found: [2] '{', 'cat'
  [07:13:16.580] Searching for globals ... DONE
  [07:13:16.580] Resolving globals: FALSE
  [07:13:16.581] 
  [07:13:16.582] 
  [07:13:16.582] 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))
  [07:13:16.586] Packages needed by the future expression (n = 0): <none>
  [07:13:16.586] Packages needed by future strategies (n = 0): <none>
  [07:13:16.591] {
  [07:13:16.591]     {
  [07:13:16.591]         ...future.startTime <- base::Sys.time()
  [07:13:16.591]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:13:16.591]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:13:16.591]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:13:16.591]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:13:16.591]             future.resolve.recursive = NULL, width = 80L)
  [07:13:16.591]         {
  [07:13:16.591]             {
  [07:13:16.591]                 base::local({
  [07:13:16.591]                   has_future <- base::requireNamespace("future", 
  [07:13:16.591]                     quietly = TRUE)
  [07:13:16.591]                   version <- if (has_future) 
  [07:13:16.591]                     utils::packageVersion("future")
  [07:13:16.591]                   else NULL
  [07:13:16.591]                   if (!has_future || version < "1.8.0") {
  [07:13:16.591]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:13:16.591]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:13:16.591]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:13:16.591]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:13:16.591]                         "release", "version")], collapse = " "), 
  [07:13:16.591]                       hostname = base::Sys.info()[["nodename"]])
  [07:13:16.591]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:13:16.591]                       info)
  [07:13:16.591]                     info <- base::paste(info, collapse = "; ")
  [07:13:16.591]                     if (!has_future) {
  [07:13:16.591]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:13:16.591]                         info)
  [07:13:16.591]                     }
  [07:13:16.591]                     else {
  [07:13:16.591]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:13:16.591]                         info, version)
  [07:13:16.591]                     }
  [07:13:16.591]                     base::stop(msg)
  [07:13:16.591]                   }
  [07:13:16.591]                 })
  [07:13:16.591]             }
  [07:13:16.591]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:13:16.591]         }
  [07:13:16.591]     }
  [07:13:16.591]     if (base::is.na(TRUE)) {
  [07:13:16.591]     }
  [07:13:16.591]     else {
  [07:13:16.591]         if (TRUE) {
  [07:13:16.591]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:13:16.591]                 open = "w")
  [07:13:16.591]         }
  [07:13:16.591]         else {
  [07:13:16.591]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:13:16.591]                 windows = "NUL", "/dev/null"), open = "w")
  [07:13:16.591]         }
  [07:13:16.591]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:13:16.591]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:13:16.591]             base::sink(type = "output", split = FALSE)
  [07:13:16.591]             base::close(...future.stdout)
  [07:13:16.591]         }, add = TRUE)
  [07:13:16.591]     }
  [07:13:16.591]     ...future.frame <- base::sys.nframe()
  [07:13:16.591]     ...future.conditions <- base::list()
  [07:13:16.591]     ...future.rng <- base::globalenv()$.Random.seed
  [07:13:16.591]     ...future.result <- base::tryCatch({
  [07:13:16.591]         base::withCallingHandlers({
  [07:13:16.591]             ...future.value <- base::withVisible(base::local({
  [07:13:16.591]                 cat("Future assignment evaluated\n")
  [07:13:16.591]                 2
  [07:13:16.591]             }))
  [07:13:16.591]             future::FutureResult(value = ...future.value$value, 
  [07:13:16.591]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.591]                   ...future.rng), started = ...future.startTime, 
  [07:13:16.591]                 version = "1.8")
  [07:13:16.591]         }, condition = base::local({
  [07:13:16.591]             c <- base::c
  [07:13:16.591]             inherits <- base::inherits
  [07:13:16.591]             invokeRestart <- base::invokeRestart
  [07:13:16.591]             length <- base::length
  [07:13:16.591]             list <- base::list
  [07:13:16.591]             seq.int <- base::seq.int
  [07:13:16.591]             signalCondition <- base::signalCondition
  [07:13:16.591]             sys.calls <- base::sys.calls
  [07:13:16.591]             Sys.time <- base::Sys.time
  [07:13:16.591]             `[[` <- base::`[[`
  [07:13:16.591]             `+` <- base::`+`
  [07:13:16.591]             `<<-` <- base::`<<-`
  [07:13:16.591]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:13:16.591]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:13:16.591]                   3L)]
  [07:13:16.591]             }
  [07:13:16.591]             function(cond) {
  [07:13:16.591]                 if (inherits(cond, "error")) {
  [07:13:16.591]                   sessionInformation <- function() {
  [07:13:16.591]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:13:16.591]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:13:16.591]                       search = base::search(), system = base::Sys.info())
  [07:13:16.591]                   }
  [07:13:16.591]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.591]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:13:16.591]                     cond$call), session = sessionInformation(), 
  [07:13:16.591]                     timestamp = Sys.time(), signaled = 0L)
  [07:13:16.591]                   signalCondition(cond)
  [07:13:16.591]                 }
  [07:13:16.591]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:13:16.591]                 ))) {
  [07:13:16.591]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:13:16.591]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.591]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:13:16.591]                   if (!signal) {
  [07:13:16.591]                     muffleCondition <- function (cond) 
  [07:13:16.591]                     {
  [07:13:16.591]                       inherits <- base::inherits
  [07:13:16.591]                       invokeRestart <- base::invokeRestart
  [07:13:16.591]                       muffled <- FALSE
  [07:13:16.591]                       if (inherits(cond, "message")) {
  [07:13:16.591]                         invokeRestart("muffleMessage")
  [07:13:16.591]                         muffled <- TRUE
  [07:13:16.591]                       }
  [07:13:16.591]                       else if (inherits(cond, "warning")) {
  [07:13:16.591]                         invokeRestart("muffleWarning")
  [07:13:16.591]                         muffled <- TRUE
  [07:13:16.591]                       }
  [07:13:16.591]                       else if (inherits(cond, "condition")) {
  [07:13:16.591]                         computeRestarts <- base::computeRestarts
  [07:13:16.591]                         grepl <- base::grepl
  [07:13:16.591]                         is.null <- base::is.null
  [07:13:16.591]                         restarts <- computeRestarts(cond)
  [07:13:16.591]                         for (restart in restarts) {
  [07:13:16.591]                           name <- restart$name
  [07:13:16.591]                           if (is.null(name)) 
  [07:13:16.591]                             next
  [07:13:16.591]                           if (!grepl("^muffle", name)) 
  [07:13:16.591]                             next
  [07:13:16.591]                           invokeRestart(restart)
  [07:13:16.591]                           muffled <- TRUE
  [07:13:16.591]                           break
  [07:13:16.591]                         }
  [07:13:16.591]                       }
  [07:13:16.591]                       invisible(muffled)
  [07:13:16.591]                     }
  [07:13:16.591]                     muffleCondition(cond)
  [07:13:16.591]                   }
  [07:13:16.591]                 }
  [07:13:16.591]             }
  [07:13:16.591]         }))
  [07:13:16.591]     }, error = function(ex) {
  [07:13:16.591]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:13:16.591]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.591]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:13:16.591]     }, finally = {
  [07:13:16.591]         {
  [07:13:16.591]             NULL
  [07:13:16.591]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:13:16.591]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:13:16.591]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:13:16.591]                 label = NULL, ...) 
  [07:13:16.591]             {
  [07:13:16.591]                 if (substitute) 
  [07:13:16.591]                   expr <- substitute(expr)
  [07:13:16.591]                 local <- as.logical(local)
  [07:13:16.591]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:13:16.591]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:13:16.591]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:13:16.591]                   label = label, ...)
  [07:13:16.591]                 if (!future$lazy) 
  [07:13:16.591]                   future <- run(future)
  [07:13:16.591]                 invisible(future)
  [07:13:16.591]             }), .cleanup = FALSE, .init = FALSE)
  [07:13:16.591]         }
  [07:13:16.591]         base::options(...future.oldOptions)
  [07:13:16.591]     })
  [07:13:16.591]     Sys.time
  [07:13:16.591]     if (base::is.na(TRUE)) {
  [07:13:16.591]     }
  [07:13:16.591]     else {
  [07:13:16.591]         base::sink(type = "output", split = FALSE)
  [07:13:16.591]         if (TRUE) {
  [07:13:16.591]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:13:16.591]         }
  [07:13:16.591]         else {
  [07:13:16.591]             ...future.result["stdout"] <- base::list(NULL)
  [07:13:16.591]         }
  [07:13:16.591]         base::close(...future.stdout)
  [07:13:16.591]         ...future.stdout <- NULL
  [07:13:16.591]     }
  [07:13:16.591]     ...future.result$conditions <- ...future.conditions
  [07:13:16.591]     ...future.result
  [07:13:16.591] }
  [07:13:16.597] plan(): Setting new future strategy stack:
  [07:13:16.597] List of future strategies:
  [07:13:16.597] 1. sequential:
  [07:13:16.597]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.597]    - tweaked: FALSE
  [07:13:16.597]    - call: NULL
  [07:13:16.598] plan(): nbrOfWorkers() = 1
  [07:13:16.600] plan(): Setting new future strategy stack:
  [07:13:16.600] List of future strategies:
  [07:13:16.600] 1. sequential:
  [07:13:16.600]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.600]    - tweaked: FALSE
  [07:13:16.600]    - call: future::plan("sequential")
  [07:13:16.601] plan(): nbrOfWorkers() = 1
  [07:13:16.602] 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 ...
  [07:13:16.672] plan(): Setting new future strategy stack:
  [07:13:16.672] List of future strategies:
  [07:13:16.672] 1. sequential:
  [07:13:16.672]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.672]    - tweaked: FALSE
  [07:13:16.672]    - call: plan(strategy)
  [07:13:16.700] plan(): nbrOfWorkers() = 1
  [07:13:16.700] getGlobalsAndPackages() ...
  [07:13:16.701] Searching for globals...
  [07:13:16.702] - globals found: [1] '{'
  [07:13:16.702] Searching for globals ... DONE
  [07:13:16.702] Resolving globals: FALSE
  [07:13:16.703] 
  [07:13:16.703] 
  [07:13:16.704] getGlobalsAndPackages() ... DONE
  [07:13:16.705] Packages needed by the future expression (n = 0): <none>
  [07:13:16.706] Packages needed by future strategies (n = 0): <none>
  [07:13:16.710] {
  [07:13:16.710]     {
  [07:13:16.710]         ...future.startTime <- base::Sys.time()
  [07:13:16.710]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:13:16.710]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:13:16.710]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:13:16.710]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:13:16.710]             future.resolve.recursive = NULL, width = 80L)
  [07:13:16.710]         {
  [07:13:16.710]             {
  [07:13:16.710]                 base::local({
  [07:13:16.710]                   has_future <- base::requireNamespace("future", 
  [07:13:16.710]                     quietly = TRUE)
  [07:13:16.710]                   version <- if (has_future) 
  [07:13:16.710]                     utils::packageVersion("future")
  [07:13:16.710]                   else NULL
  [07:13:16.710]                   if (!has_future || version < "1.8.0") {
  [07:13:16.710]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:13:16.710]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:13:16.710]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:13:16.710]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:13:16.710]                         "release", "version")], collapse = " "), 
  [07:13:16.710]                       hostname = base::Sys.info()[["nodename"]])
  [07:13:16.710]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:13:16.710]                       info)
  [07:13:16.710]                     info <- base::paste(info, collapse = "; ")
  [07:13:16.710]                     if (!has_future) {
  [07:13:16.710]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:13:16.710]                         info)
  [07:13:16.710]                     }
  [07:13:16.710]                     else {
  [07:13:16.710]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:13:16.710]                         info, version)
  [07:13:16.710]                     }
  [07:13:16.710]                     base::stop(msg)
  [07:13:16.710]                   }
  [07:13:16.710]                 })
  [07:13:16.710]             }
  [07:13:16.710]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:13:16.710]         }
  [07:13:16.710]     }
  [07:13:16.710]     if (base::is.na(TRUE)) {
  [07:13:16.710]     }
  [07:13:16.710]     else {
  [07:13:16.710]         if (TRUE) {
  [07:13:16.710]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:13:16.710]                 open = "w")
  [07:13:16.710]         }
  [07:13:16.710]         else {
  [07:13:16.710]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:13:16.710]                 windows = "NUL", "/dev/null"), open = "w")
  [07:13:16.710]         }
  [07:13:16.710]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:13:16.710]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:13:16.710]             base::sink(type = "output", split = FALSE)
  [07:13:16.710]             base::close(...future.stdout)
  [07:13:16.710]         }, add = TRUE)
  [07:13:16.710]     }
  [07:13:16.710]     ...future.frame <- base::sys.nframe()
  [07:13:16.710]     ...future.conditions <- base::list()
  [07:13:16.710]     ...future.rng <- base::globalenv()$.Random.seed
  [07:13:16.710]     ...future.result <- base::tryCatch({
  [07:13:16.710]         base::withCallingHandlers({
  [07:13:16.710]             ...future.value <- base::withVisible(base::local({
  [07:13:16.710]                 2
  [07:13:16.710]             }))
  [07:13:16.710]             future::FutureResult(value = ...future.value$value, 
  [07:13:16.710]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.710]                   ...future.rng), started = ...future.startTime, 
  [07:13:16.710]                 version = "1.8")
  [07:13:16.710]         }, condition = base::local({
  [07:13:16.710]             c <- base::c
  [07:13:16.710]             inherits <- base::inherits
  [07:13:16.710]             invokeRestart <- base::invokeRestart
  [07:13:16.710]             length <- base::length
  [07:13:16.710]             list <- base::list
  [07:13:16.710]             seq.int <- base::seq.int
  [07:13:16.710]             signalCondition <- base::signalCondition
  [07:13:16.710]             sys.calls <- base::sys.calls
  [07:13:16.710]             Sys.time <- base::Sys.time
  [07:13:16.710]             `[[` <- base::`[[`
  [07:13:16.710]             `+` <- base::`+`
  [07:13:16.710]             `<<-` <- base::`<<-`
  [07:13:16.710]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:13:16.710]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:13:16.710]                   3L)]
  [07:13:16.710]             }
  [07:13:16.710]             function(cond) {
  [07:13:16.710]                 if (inherits(cond, "error")) {
  [07:13:16.710]                   sessionInformation <- function() {
  [07:13:16.710]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:13:16.710]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:13:16.710]                       search = base::search(), system = base::Sys.info())
  [07:13:16.710]                   }
  [07:13:16.710]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.710]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:13:16.710]                     cond$call), session = sessionInformation(), 
  [07:13:16.710]                     timestamp = Sys.time(), signaled = 0L)
  [07:13:16.710]                   signalCondition(cond)
  [07:13:16.710]                 }
  [07:13:16.710]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:13:16.710]                 ))) {
  [07:13:16.710]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:13:16.710]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.710]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:13:16.710]                   if (!signal) {
  [07:13:16.710]                     muffleCondition <- function (cond) 
  [07:13:16.710]                     {
  [07:13:16.710]                       inherits <- base::inherits
  [07:13:16.710]                       invokeRestart <- base::invokeRestart
  [07:13:16.710]                       muffled <- FALSE
  [07:13:16.710]                       if (inherits(cond, "message")) {
  [07:13:16.710]                         invokeRestart("muffleMessage")
  [07:13:16.710]                         muffled <- TRUE
  [07:13:16.710]                       }
  [07:13:16.710]                       else if (inherits(cond, "warning")) {
  [07:13:16.710]                         invokeRestart("muffleWarning")
  [07:13:16.710]                         muffled <- TRUE
  [07:13:16.710]                       }
  [07:13:16.710]                       else if (inherits(cond, "condition")) {
  [07:13:16.710]                         computeRestarts <- base::computeRestarts
  [07:13:16.710]                         grepl <- base::grepl
  [07:13:16.710]                         is.null <- base::is.null
  [07:13:16.710]                         restarts <- computeRestarts(cond)
  [07:13:16.710]                         for (restart in restarts) {
  [07:13:16.710]                           name <- restart$name
  [07:13:16.710]                           if (is.null(name)) 
  [07:13:16.710]                             next
  [07:13:16.710]                           if (!grepl("^muffle", name)) 
  [07:13:16.710]                             next
  [07:13:16.710]                           invokeRestart(restart)
  [07:13:16.710]                           muffled <- TRUE
  [07:13:16.710]                           break
  [07:13:16.710]                         }
  [07:13:16.710]                       }
  [07:13:16.710]                       invisible(muffled)
  [07:13:16.710]                     }
  [07:13:16.710]                     muffleCondition(cond)
  [07:13:16.710]                   }
  [07:13:16.710]                 }
  [07:13:16.710]             }
  [07:13:16.710]         }))
  [07:13:16.710]     }, error = function(ex) {
  [07:13:16.710]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:13:16.710]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.710]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:13:16.710]     }, finally = {
  [07:13:16.710]         {
  [07:13:16.710]             NULL
  [07:13:16.710]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:13:16.710]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:13:16.710]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:13:16.710]                 label = NULL, ...) 
  [07:13:16.710]             {
  [07:13:16.710]                 if (substitute) 
  [07:13:16.710]                   expr <- substitute(expr)
  [07:13:16.710]                 local <- as.logical(local)
  [07:13:16.710]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:13:16.710]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:13:16.710]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:13:16.710]                   label = label, ...)
  [07:13:16.710]                 if (!future$lazy) 
  [07:13:16.710]                   future <- run(future)
  [07:13:16.710]                 invisible(future)
  [07:13:16.710]             }), .cleanup = FALSE, .init = FALSE)
  [07:13:16.710]         }
  [07:13:16.710]         base::options(...future.oldOptions)
  [07:13:16.710]     })
  [07:13:16.710]     Sys.time
  [07:13:16.710]     if (base::is.na(TRUE)) {
  [07:13:16.710]     }
  [07:13:16.710]     else {
  [07:13:16.710]         base::sink(type = "output", split = FALSE)
  [07:13:16.710]         if (TRUE) {
  [07:13:16.710]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:13:16.710]         }
  [07:13:16.710]         else {
  [07:13:16.710]             ...future.result["stdout"] <- base::list(NULL)
  [07:13:16.710]         }
  [07:13:16.710]         base::close(...future.stdout)
  [07:13:16.710]         ...future.stdout <- NULL
  [07:13:16.710]     }
  [07:13:16.710]     ...future.result$conditions <- ...future.conditions
  [07:13:16.710]     ...future.result
  [07:13:16.710] }
  [07:13:16.715] plan(): Setting new future strategy stack:
  [07:13:16.715] List of future strategies:
  [07:13:16.715] 1. sequential:
  [07:13:16.715]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.715]    - tweaked: FALSE
  [07:13:16.715]    - call: NULL
  [07:13:16.716] plan(): nbrOfWorkers() = 1
  [07:13:16.717] plan(): Setting new future strategy stack:
  [07:13:16.718] List of future strategies:
  [07:13:16.718] 1. sequential:
  [07:13:16.718]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.718]    - tweaked: FALSE
  [07:13:16.718]    - call: plan(strategy)
  [07:13:16.719] plan(): nbrOfWorkers() = 1
  [07:13:16.719] SequentialFuture started (and completed)
  [07:13:16.720] getGlobalsAndPackages() ...
  [07:13:16.720] Searching for globals...
  [07:13:16.721] - globals found: [1] '{'
  [07:13:16.721] Searching for globals ... DONE
  [07:13:16.722] Resolving globals: FALSE
  [07:13:16.722] 
  [07:13:16.723] 
  [07:13:16.723] getGlobalsAndPackages() ... DONE
  [07:13:16.725] Packages needed by the future expression (n = 0): <none>
  [07:13:16.725] Packages needed by future strategies (n = 0): <none>
  [07:13:16.729] {
  [07:13:16.729]     {
  [07:13:16.729]         ...future.startTime <- base::Sys.time()
  [07:13:16.729]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:13:16.729]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:13:16.729]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:13:16.729]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:13:16.729]             future.resolve.recursive = NULL, width = 80L)
  [07:13:16.729]         {
  [07:13:16.729]             {
  [07:13:16.729]                 base::local({
  [07:13:16.729]                   has_future <- base::requireNamespace("future", 
  [07:13:16.729]                     quietly = TRUE)
  [07:13:16.729]                   version <- if (has_future) 
  [07:13:16.729]                     utils::packageVersion("future")
  [07:13:16.729]                   else NULL
  [07:13:16.729]                   if (!has_future || version < "1.8.0") {
  [07:13:16.729]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:13:16.729]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:13:16.729]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:13:16.729]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:13:16.729]                         "release", "version")], collapse = " "), 
  [07:13:16.729]                       hostname = base::Sys.info()[["nodename"]])
  [07:13:16.729]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:13:16.729]                       info)
  [07:13:16.729]                     info <- base::paste(info, collapse = "; ")
  [07:13:16.729]                     if (!has_future) {
  [07:13:16.729]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:13:16.729]                         info)
  [07:13:16.729]                     }
  [07:13:16.729]                     else {
  [07:13:16.729]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:13:16.729]                         info, version)
  [07:13:16.729]                     }
  [07:13:16.729]                     base::stop(msg)
  [07:13:16.729]                   }
  [07:13:16.729]                 })
  [07:13:16.729]             }
  [07:13:16.729]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:13:16.729]         }
  [07:13:16.729]     }
  [07:13:16.729]     if (base::is.na(TRUE)) {
  [07:13:16.729]     }
  [07:13:16.729]     else {
  [07:13:16.729]         if (TRUE) {
  [07:13:16.729]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:13:16.729]                 open = "w")
  [07:13:16.729]         }
  [07:13:16.729]         else {
  [07:13:16.729]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:13:16.729]                 windows = "NUL", "/dev/null"), open = "w")
  [07:13:16.729]         }
  [07:13:16.729]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:13:16.729]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:13:16.729]             base::sink(type = "output", split = FALSE)
  [07:13:16.729]             base::close(...future.stdout)
  [07:13:16.729]         }, add = TRUE)
  [07:13:16.729]     }
  [07:13:16.729]     ...future.frame <- base::sys.nframe()
  [07:13:16.729]     ...future.conditions <- base::list()
  [07:13:16.729]     ...future.rng <- base::globalenv()$.Random.seed
  [07:13:16.729]     ...future.result <- base::tryCatch({
  [07:13:16.729]         base::withCallingHandlers({
  [07:13:16.729]             ...future.value <- base::withVisible(base::local({
  [07:13:16.729]                 4
  [07:13:16.729]             }))
  [07:13:16.729]             future::FutureResult(value = ...future.value$value, 
  [07:13:16.729]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.729]                   ...future.rng), started = ...future.startTime, 
  [07:13:16.729]                 version = "1.8")
  [07:13:16.729]         }, condition = base::local({
  [07:13:16.729]             c <- base::c
  [07:13:16.729]             inherits <- base::inherits
  [07:13:16.729]             invokeRestart <- base::invokeRestart
  [07:13:16.729]             length <- base::length
  [07:13:16.729]             list <- base::list
  [07:13:16.729]             seq.int <- base::seq.int
  [07:13:16.729]             signalCondition <- base::signalCondition
  [07:13:16.729]             sys.calls <- base::sys.calls
  [07:13:16.729]             Sys.time <- base::Sys.time
  [07:13:16.729]             `[[` <- base::`[[`
  [07:13:16.729]             `+` <- base::`+`
  [07:13:16.729]             `<<-` <- base::`<<-`
  [07:13:16.729]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:13:16.729]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:13:16.729]                   3L)]
  [07:13:16.729]             }
  [07:13:16.729]             function(cond) {
  [07:13:16.729]                 if (inherits(cond, "error")) {
  [07:13:16.729]                   sessionInformation <- function() {
  [07:13:16.729]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:13:16.729]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:13:16.729]                       search = base::search(), system = base::Sys.info())
  [07:13:16.729]                   }
  [07:13:16.729]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.729]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:13:16.729]                     cond$call), session = sessionInformation(), 
  [07:13:16.729]                     timestamp = Sys.time(), signaled = 0L)
  [07:13:16.729]                   signalCondition(cond)
  [07:13:16.729]                 }
  [07:13:16.729]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:13:16.729]                 ))) {
  [07:13:16.729]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:13:16.729]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.729]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:13:16.729]                   if (!signal) {
  [07:13:16.729]                     muffleCondition <- function (cond) 
  [07:13:16.729]                     {
  [07:13:16.729]                       inherits <- base::inherits
  [07:13:16.729]                       invokeRestart <- base::invokeRestart
  [07:13:16.729]                       muffled <- FALSE
  [07:13:16.729]                       if (inherits(cond, "message")) {
  [07:13:16.729]                         invokeRestart("muffleMessage")
  [07:13:16.729]                         muffled <- TRUE
  [07:13:16.729]                       }
  [07:13:16.729]                       else if (inherits(cond, "warning")) {
  [07:13:16.729]                         invokeRestart("muffleWarning")
  [07:13:16.729]                         muffled <- TRUE
  [07:13:16.729]                       }
  [07:13:16.729]                       else if (inherits(cond, "condition")) {
  [07:13:16.729]                         computeRestarts <- base::computeRestarts
  [07:13:16.729]                         grepl <- base::grepl
  [07:13:16.729]                         is.null <- base::is.null
  [07:13:16.729]                         restarts <- computeRestarts(cond)
  [07:13:16.729]                         for (restart in restarts) {
  [07:13:16.729]                           name <- restart$name
  [07:13:16.729]                           if (is.null(name)) 
  [07:13:16.729]                             next
  [07:13:16.729]                           if (!grepl("^muffle", name)) 
  [07:13:16.729]                             next
  [07:13:16.729]                           invokeRestart(restart)
  [07:13:16.729]                           muffled <- TRUE
  [07:13:16.729]                           break
  [07:13:16.729]                         }
  [07:13:16.729]                       }
  [07:13:16.729]                       invisible(muffled)
  [07:13:16.729]                     }
  [07:13:16.729]                     muffleCondition(cond)
  [07:13:16.729]                   }
  [07:13:16.729]                 }
  [07:13:16.729]             }
  [07:13:16.729]         }))
  [07:13:16.729]     }, error = function(ex) {
  [07:13:16.729]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:13:16.729]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.729]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:13:16.729]     }, finally = {
  [07:13:16.729]         {
  [07:13:16.729]             NULL
  [07:13:16.729]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:13:16.729]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:13:16.729]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:13:16.729]                 label = NULL, ...) 
  [07:13:16.729]             {
  [07:13:16.729]                 if (substitute) 
  [07:13:16.729]                   expr <- substitute(expr)
  [07:13:16.729]                 local <- as.logical(local)
  [07:13:16.729]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:13:16.729]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:13:16.729]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:13:16.729]                   label = label, ...)
  [07:13:16.729]                 if (!future$lazy) 
  [07:13:16.729]                   future <- run(future)
  [07:13:16.729]                 invisible(future)
  [07:13:16.729]             }), .cleanup = FALSE, .init = FALSE)
  [07:13:16.729]         }
  [07:13:16.729]         base::options(...future.oldOptions)
  [07:13:16.729]     })
  [07:13:16.729]     Sys.time
  [07:13:16.729]     if (base::is.na(TRUE)) {
  [07:13:16.729]     }
  [07:13:16.729]     else {
  [07:13:16.729]         base::sink(type = "output", split = FALSE)
  [07:13:16.729]         if (TRUE) {
  [07:13:16.729]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:13:16.729]         }
  [07:13:16.729]         else {
  [07:13:16.729]             ...future.result["stdout"] <- base::list(NULL)
  [07:13:16.729]         }
  [07:13:16.729]         base::close(...future.stdout)
  [07:13:16.729]         ...future.stdout <- NULL
  [07:13:16.729]     }
  [07:13:16.729]     ...future.result$conditions <- ...future.conditions
  [07:13:16.729]     ...future.result
  [07:13:16.729] }
  [07:13:16.734] plan(): Setting new future strategy stack:
  [07:13:16.734] List of future strategies:
  [07:13:16.734] 1. sequential:
  [07:13:16.734]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.734]    - tweaked: FALSE
  [07:13:16.734]    - call: NULL
  [07:13:16.735] plan(): nbrOfWorkers() = 1
  [07:13:16.736] plan(): Setting new future strategy stack:
  [07:13:16.737] List of future strategies:
  [07:13:16.737] 1. sequential:
  [07:13:16.737]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.737]    - tweaked: FALSE
  [07:13:16.737]    - call: plan(strategy)
  [07:13:16.738] plan(): nbrOfWorkers() = 1
  [07:13:16.738] SequentialFuture started (and completed)
  u$a = 2
  v$a = 4
  [07:13:16.739] getGlobalsAndPackages() ...
  [07:13:16.740] Searching for globals...
  [07:13:16.741] - globals found: [3] '{', '*', 'a'
  [07:13:16.742] Searching for globals ... DONE
  [07:13:16.742] Resolving globals: FALSE
  [07:13:16.743] The total size of the 1 globals is 56 bytes (56 bytes)
  [07:13:16.744] - globals: [1] 'a'
  [07:13:16.744] 
  [07:13:16.744] getGlobalsAndPackages() ... DONE
  [07:13:16.746] Packages needed by the future expression (n = 0): <none>
  [07:13:16.746] Packages needed by future strategies (n = 0): <none>
  [07:13:16.750] {
  [07:13:16.750]     {
  [07:13:16.750]         ...future.startTime <- base::Sys.time()
  [07:13:16.750]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:13:16.750]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:13:16.750]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:13:16.750]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:13:16.750]             future.resolve.recursive = NULL, width = 80L)
  [07:13:16.750]         {
  [07:13:16.750]             {
  [07:13:16.750]                 base::local({
  [07:13:16.750]                   has_future <- base::requireNamespace("future", 
  [07:13:16.750]                     quietly = TRUE)
  [07:13:16.750]                   version <- if (has_future) 
  [07:13:16.750]                     utils::packageVersion("future")
  [07:13:16.750]                   else NULL
  [07:13:16.750]                   if (!has_future || version < "1.8.0") {
  [07:13:16.750]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:13:16.750]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:13:16.750]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:13:16.750]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:13:16.750]                         "release", "version")], collapse = " "), 
  [07:13:16.750]                       hostname = base::Sys.info()[["nodename"]])
  [07:13:16.750]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:13:16.750]                       info)
  [07:13:16.750]                     info <- base::paste(info, collapse = "; ")
  [07:13:16.750]                     if (!has_future) {
  [07:13:16.750]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:13:16.750]                         info)
  [07:13:16.750]                     }
  [07:13:16.750]                     else {
  [07:13:16.750]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:13:16.750]                         info, version)
  [07:13:16.750]                     }
  [07:13:16.750]                     base::stop(msg)
  [07:13:16.750]                   }
  [07:13:16.750]                 })
  [07:13:16.750]             }
  [07:13:16.750]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:13:16.750]         }
  [07:13:16.750]     }
  [07:13:16.750]     if (base::is.na(TRUE)) {
  [07:13:16.750]     }
  [07:13:16.750]     else {
  [07:13:16.750]         if (TRUE) {
  [07:13:16.750]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:13:16.750]                 open = "w")
  [07:13:16.750]         }
  [07:13:16.750]         else {
  [07:13:16.750]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:13:16.750]                 windows = "NUL", "/dev/null"), open = "w")
  [07:13:16.750]         }
  [07:13:16.750]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:13:16.750]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:13:16.750]             base::sink(type = "output", split = FALSE)
  [07:13:16.750]             base::close(...future.stdout)
  [07:13:16.750]         }, add = TRUE)
  [07:13:16.750]     }
  [07:13:16.750]     ...future.frame <- base::sys.nframe()
  [07:13:16.750]     ...future.conditions <- base::list()
  [07:13:16.750]     ...future.rng <- base::globalenv()$.Random.seed
  [07:13:16.750]     ...future.result <- base::tryCatch({
  [07:13:16.750]         base::withCallingHandlers({
  [07:13:16.750]             ...future.value <- base::withVisible(base::local({
  [07:13:16.750]                 2 * a
  [07:13:16.750]             }))
  [07:13:16.750]             future::FutureResult(value = ...future.value$value, 
  [07:13:16.750]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.750]                   ...future.rng), started = ...future.startTime, 
  [07:13:16.750]                 version = "1.8")
  [07:13:16.750]         }, condition = base::local({
  [07:13:16.750]             c <- base::c
  [07:13:16.750]             inherits <- base::inherits
  [07:13:16.750]             invokeRestart <- base::invokeRestart
  [07:13:16.750]             length <- base::length
  [07:13:16.750]             list <- base::list
  [07:13:16.750]             seq.int <- base::seq.int
  [07:13:16.750]             signalCondition <- base::signalCondition
  [07:13:16.750]             sys.calls <- base::sys.calls
  [07:13:16.750]             Sys.time <- base::Sys.time
  [07:13:16.750]             `[[` <- base::`[[`
  [07:13:16.750]             `+` <- base::`+`
  [07:13:16.750]             `<<-` <- base::`<<-`
  [07:13:16.750]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:13:16.750]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:13:16.750]                   3L)]
  [07:13:16.750]             }
  [07:13:16.750]             function(cond) {
  [07:13:16.750]                 if (inherits(cond, "error")) {
  [07:13:16.750]                   sessionInformation <- function() {
  [07:13:16.750]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:13:16.750]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:13:16.750]                       search = base::search(), system = base::Sys.info())
  [07:13:16.750]                   }
  [07:13:16.750]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.750]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:13:16.750]                     cond$call), session = sessionInformation(), 
  [07:13:16.750]                     timestamp = Sys.time(), signaled = 0L)
  [07:13:16.750]                   signalCondition(cond)
  [07:13:16.750]                 }
  [07:13:16.750]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:13:16.750]                 ))) {
  [07:13:16.750]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:13:16.750]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.750]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:13:16.750]                   if (!signal) {
  [07:13:16.750]                     muffleCondition <- function (cond) 
  [07:13:16.750]                     {
  [07:13:16.750]                       inherits <- base::inherits
  [07:13:16.750]                       invokeRestart <- base::invokeRestart
  [07:13:16.750]                       muffled <- FALSE
  [07:13:16.750]                       if (inherits(cond, "message")) {
  [07:13:16.750]                         invokeRestart("muffleMessage")
  [07:13:16.750]                         muffled <- TRUE
  [07:13:16.750]                       }
  [07:13:16.750]                       else if (inherits(cond, "warning")) {
  [07:13:16.750]                         invokeRestart("muffleWarning")
  [07:13:16.750]                         muffled <- TRUE
  [07:13:16.750]                       }
  [07:13:16.750]                       else if (inherits(cond, "condition")) {
  [07:13:16.750]                         computeRestarts <- base::computeRestarts
  [07:13:16.750]                         grepl <- base::grepl
  [07:13:16.750]                         is.null <- base::is.null
  [07:13:16.750]                         restarts <- computeRestarts(cond)
  [07:13:16.750]                         for (restart in restarts) {
  [07:13:16.750]                           name <- restart$name
  [07:13:16.750]                           if (is.null(name)) 
  [07:13:16.750]                             next
  [07:13:16.750]                           if (!grepl("^muffle", name)) 
  [07:13:16.750]                             next
  [07:13:16.750]                           invokeRestart(restart)
  [07:13:16.750]                           muffled <- TRUE
  [07:13:16.750]                           break
  [07:13:16.750]                         }
  [07:13:16.750]                       }
  [07:13:16.750]                       invisible(muffled)
  [07:13:16.750]                     }
  [07:13:16.750]                     muffleCondition(cond)
  [07:13:16.750]                   }
  [07:13:16.750]                 }
  [07:13:16.750]             }
  [07:13:16.750]         }))
  [07:13:16.750]     }, error = function(ex) {
  [07:13:16.750]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:13:16.750]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.750]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:13:16.750]     }, finally = {
  [07:13:16.750]         {
  [07:13:16.750]             NULL
  [07:13:16.750]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:13:16.750]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:13:16.750]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:13:16.750]                 label = NULL, ...) 
  [07:13:16.750]             {
  [07:13:16.750]                 if (substitute) 
  [07:13:16.750]                   expr <- substitute(expr)
  [07:13:16.750]                 local <- as.logical(local)
  [07:13:16.750]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:13:16.750]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:13:16.750]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:13:16.750]                   label = label, ...)
  [07:13:16.750]                 if (!future$lazy) 
  [07:13:16.750]                   future <- run(future)
  [07:13:16.750]                 invisible(future)
  [07:13:16.750]             }), .cleanup = FALSE, .init = FALSE)
  [07:13:16.750]         }
  [07:13:16.750]         base::options(...future.oldOptions)
  [07:13:16.750]     })
  [07:13:16.750]     Sys.time
  [07:13:16.750]     if (base::is.na(TRUE)) {
  [07:13:16.750]     }
  [07:13:16.750]     else {
  [07:13:16.750]         base::sink(type = "output", split = FALSE)
  [07:13:16.750]         if (TRUE) {
  [07:13:16.750]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:13:16.750]         }
  [07:13:16.750]         else {
  [07:13:16.750]             ...future.result["stdout"] <- base::list(NULL)
  [07:13:16.750]         }
  [07:13:16.750]         base::close(...future.stdout)
  [07:13:16.750]         ...future.stdout <- NULL
  [07:13:16.750]     }
  [07:13:16.750]     ...future.result$conditions <- ...future.conditions
  [07:13:16.750]     ...future.result
  [07:13:16.750] }
  [07:13:16.755] plan(): Setting new future strategy stack:
  [07:13:16.755] List of future strategies:
  [07:13:16.755] 1. sequential:
  [07:13:16.755]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.755]    - tweaked: FALSE
  [07:13:16.755]    - call: NULL
  [07:13:16.756] plan(): nbrOfWorkers() = 1
  [07:13:16.757] plan(): Setting new future strategy stack:
  [07:13:16.758] List of future strategies:
  [07:13:16.758] 1. sequential:
  [07:13:16.758]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.758]    - tweaked: FALSE
  [07:13:16.758]    - call: plan(strategy)
  [07:13:16.759] plan(): nbrOfWorkers() = 1
  [07:13:16.759] SequentialFuture started (and completed)
  [07:13:16.760] getGlobalsAndPackages() ...
  [07:13:16.760] Searching for globals...
  [07:13:16.762] - globals found: [3] '{', '*', 'a'
  [07:13:16.762] Searching for globals ... DONE
  [07:13:16.763] Resolving globals: FALSE
  [07:13:16.767] The total size of the 1 globals is 56 bytes (56 bytes)
  [07:13:16.767] - globals: [1] 'a'
  [07:13:16.768] 
  [07:13:16.768] getGlobalsAndPackages() ... DONE
  [07:13:16.770] Packages needed by the future expression (n = 0): <none>
  [07:13:16.770] Packages needed by future strategies (n = 0): <none>
  [07:13:16.774] {
  [07:13:16.774]     {
  [07:13:16.774]         ...future.startTime <- base::Sys.time()
  [07:13:16.774]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:13:16.774]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:13:16.774]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:13:16.774]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:13:16.774]             future.resolve.recursive = NULL, width = 80L)
  [07:13:16.774]         {
  [07:13:16.774]             {
  [07:13:16.774]                 base::local({
  [07:13:16.774]                   has_future <- base::requireNamespace("future", 
  [07:13:16.774]                     quietly = TRUE)
  [07:13:16.774]                   version <- if (has_future) 
  [07:13:16.774]                     utils::packageVersion("future")
  [07:13:16.774]                   else NULL
  [07:13:16.774]                   if (!has_future || version < "1.8.0") {
  [07:13:16.774]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:13:16.774]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:13:16.774]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:13:16.774]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:13:16.774]                         "release", "version")], collapse = " "), 
  [07:13:16.774]                       hostname = base::Sys.info()[["nodename"]])
  [07:13:16.774]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:13:16.774]                       info)
  [07:13:16.774]                     info <- base::paste(info, collapse = "; ")
  [07:13:16.774]                     if (!has_future) {
  [07:13:16.774]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:13:16.774]                         info)
  [07:13:16.774]                     }
  [07:13:16.774]                     else {
  [07:13:16.774]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:13:16.774]                         info, version)
  [07:13:16.774]                     }
  [07:13:16.774]                     base::stop(msg)
  [07:13:16.774]                   }
  [07:13:16.774]                 })
  [07:13:16.774]             }
  [07:13:16.774]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:13:16.774]         }
  [07:13:16.774]     }
  [07:13:16.774]     if (base::is.na(TRUE)) {
  [07:13:16.774]     }
  [07:13:16.774]     else {
  [07:13:16.774]         if (TRUE) {
  [07:13:16.774]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:13:16.774]                 open = "w")
  [07:13:16.774]         }
  [07:13:16.774]         else {
  [07:13:16.774]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:13:16.774]                 windows = "NUL", "/dev/null"), open = "w")
  [07:13:16.774]         }
  [07:13:16.774]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:13:16.774]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:13:16.774]             base::sink(type = "output", split = FALSE)
  [07:13:16.774]             base::close(...future.stdout)
  [07:13:16.774]         }, add = TRUE)
  [07:13:16.774]     }
  [07:13:16.774]     ...future.frame <- base::sys.nframe()
  [07:13:16.774]     ...future.conditions <- base::list()
  [07:13:16.774]     ...future.rng <- base::globalenv()$.Random.seed
  [07:13:16.774]     ...future.result <- base::tryCatch({
  [07:13:16.774]         base::withCallingHandlers({
  [07:13:16.774]             ...future.value <- base::withVisible(base::local({
  [07:13:16.774]                 2 * a
  [07:13:16.774]             }))
  [07:13:16.774]             future::FutureResult(value = ...future.value$value, 
  [07:13:16.774]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.774]                   ...future.rng), started = ...future.startTime, 
  [07:13:16.774]                 version = "1.8")
  [07:13:16.774]         }, condition = base::local({
  [07:13:16.774]             c <- base::c
  [07:13:16.774]             inherits <- base::inherits
  [07:13:16.774]             invokeRestart <- base::invokeRestart
  [07:13:16.774]             length <- base::length
  [07:13:16.774]             list <- base::list
  [07:13:16.774]             seq.int <- base::seq.int
  [07:13:16.774]             signalCondition <- base::signalCondition
  [07:13:16.774]             sys.calls <- base::sys.calls
  [07:13:16.774]             Sys.time <- base::Sys.time
  [07:13:16.774]             `[[` <- base::`[[`
  [07:13:16.774]             `+` <- base::`+`
  [07:13:16.774]             `<<-` <- base::`<<-`
  [07:13:16.774]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:13:16.774]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:13:16.774]                   3L)]
  [07:13:16.774]             }
  [07:13:16.774]             function(cond) {
  [07:13:16.774]                 if (inherits(cond, "error")) {
  [07:13:16.774]                   sessionInformation <- function() {
  [07:13:16.774]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:13:16.774]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:13:16.774]                       search = base::search(), system = base::Sys.info())
  [07:13:16.774]                   }
  [07:13:16.774]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.774]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:13:16.774]                     cond$call), session = sessionInformation(), 
  [07:13:16.774]                     timestamp = Sys.time(), signaled = 0L)
  [07:13:16.774]                   signalCondition(cond)
  [07:13:16.774]                 }
  [07:13:16.774]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:13:16.774]                 ))) {
  [07:13:16.774]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:13:16.774]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.774]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:13:16.774]                   if (!signal) {
  [07:13:16.774]                     muffleCondition <- function (cond) 
  [07:13:16.774]                     {
  [07:13:16.774]                       inherits <- base::inherits
  [07:13:16.774]                       invokeRestart <- base::invokeRestart
  [07:13:16.774]                       muffled <- FALSE
  [07:13:16.774]                       if (inherits(cond, "message")) {
  [07:13:16.774]                         invokeRestart("muffleMessage")
  [07:13:16.774]                         muffled <- TRUE
  [07:13:16.774]                       }
  [07:13:16.774]                       else if (inherits(cond, "warning")) {
  [07:13:16.774]                         invokeRestart("muffleWarning")
  [07:13:16.774]                         muffled <- TRUE
  [07:13:16.774]                       }
  [07:13:16.774]                       else if (inherits(cond, "condition")) {
  [07:13:16.774]                         computeRestarts <- base::computeRestarts
  [07:13:16.774]                         grepl <- base::grepl
  [07:13:16.774]                         is.null <- base::is.null
  [07:13:16.774]                         restarts <- computeRestarts(cond)
  [07:13:16.774]                         for (restart in restarts) {
  [07:13:16.774]                           name <- restart$name
  [07:13:16.774]                           if (is.null(name)) 
  [07:13:16.774]                             next
  [07:13:16.774]                           if (!grepl("^muffle", name)) 
  [07:13:16.774]                             next
  [07:13:16.774]                           invokeRestart(restart)
  [07:13:16.774]                           muffled <- TRUE
  [07:13:16.774]                           break
  [07:13:16.774]                         }
  [07:13:16.774]                       }
  [07:13:16.774]                       invisible(muffled)
  [07:13:16.774]                     }
  [07:13:16.774]                     muffleCondition(cond)
  [07:13:16.774]                   }
  [07:13:16.774]                 }
  [07:13:16.774]             }
  [07:13:16.774]         }))
  [07:13:16.774]     }, error = function(ex) {
  [07:13:16.774]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:13:16.774]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.774]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:13:16.774]     }, finally = {
  [07:13:16.774]         {
  [07:13:16.774]             NULL
  [07:13:16.774]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:13:16.774]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:13:16.774]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:13:16.774]                 label = NULL, ...) 
  [07:13:16.774]             {
  [07:13:16.774]                 if (substitute) 
  [07:13:16.774]                   expr <- substitute(expr)
  [07:13:16.774]                 local <- as.logical(local)
  [07:13:16.774]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:13:16.774]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:13:16.774]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:13:16.774]                   label = label, ...)
  [07:13:16.774]                 if (!future$lazy) 
  [07:13:16.774]                   future <- run(future)
  [07:13:16.774]                 invisible(future)
  [07:13:16.774]             }), .cleanup = FALSE, .init = FALSE)
  [07:13:16.774]         }
  [07:13:16.774]         base::options(...future.oldOptions)
  [07:13:16.774]     })
  [07:13:16.774]     Sys.time
  [07:13:16.774]     if (base::is.na(TRUE)) {
  [07:13:16.774]     }
  [07:13:16.774]     else {
  [07:13:16.774]         base::sink(type = "output", split = FALSE)
  [07:13:16.774]         if (TRUE) {
  [07:13:16.774]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:13:16.774]         }
  [07:13:16.774]         else {
  [07:13:16.774]             ...future.result["stdout"] <- base::list(NULL)
  [07:13:16.774]         }
  [07:13:16.774]         base::close(...future.stdout)
  [07:13:16.774]         ...future.stdout <- NULL
  [07:13:16.774]     }
  [07:13:16.774]     ...future.result$conditions <- ...future.conditions
  [07:13:16.774]     ...future.result
  [07:13:16.774] }
  [07:13:16.779] plan(): Setting new future strategy stack:
  [07:13:16.779] List of future strategies:
  [07:13:16.779] 1. sequential:
  [07:13:16.779]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.779]    - tweaked: FALSE
  [07:13:16.779]    - call: NULL
  [07:13:16.780] plan(): nbrOfWorkers() = 1
  [07:13:16.781] plan(): Setting new future strategy stack:
  [07:13:16.782] List of future strategies:
  [07:13:16.782] 1. sequential:
  [07:13:16.782]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.782]    - tweaked: FALSE
  [07:13:16.782]    - call: plan(strategy)
  [07:13:16.783] plan(): nbrOfWorkers() = 1
  [07:13:16.783] SequentialFuture started (and completed)
  [07:13:16.784] getGlobalsAndPackages() ...
  [07:13:16.784] Searching for globals...
  [07:13:16.786] - globals found: [3] '{', '*', 'a'
  [07:13:16.786] Searching for globals ... DONE
  [07:13:16.787] Resolving globals: FALSE
  [07:13:16.788] The total size of the 1 globals is 56 bytes (56 bytes)
  [07:13:16.788] - globals: [1] 'a'
  [07:13:16.788] 
  [07:13:16.789] getGlobalsAndPackages() ... DONE
  [07:13:16.790] Packages needed by the future expression (n = 0): <none>
  [07:13:16.791] Packages needed by future strategies (n = 0): <none>
  [07:13:16.795] {
  [07:13:16.795]     {
  [07:13:16.795]         ...future.startTime <- base::Sys.time()
  [07:13:16.795]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:13:16.795]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:13:16.795]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:13:16.795]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:13:16.795]             future.resolve.recursive = NULL, width = 80L)
  [07:13:16.795]         {
  [07:13:16.795]             {
  [07:13:16.795]                 base::local({
  [07:13:16.795]                   has_future <- base::requireNamespace("future", 
  [07:13:16.795]                     quietly = TRUE)
  [07:13:16.795]                   version <- if (has_future) 
  [07:13:16.795]                     utils::packageVersion("future")
  [07:13:16.795]                   else NULL
  [07:13:16.795]                   if (!has_future || version < "1.8.0") {
  [07:13:16.795]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:13:16.795]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:13:16.795]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:13:16.795]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:13:16.795]                         "release", "version")], collapse = " "), 
  [07:13:16.795]                       hostname = base::Sys.info()[["nodename"]])
  [07:13:16.795]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:13:16.795]                       info)
  [07:13:16.795]                     info <- base::paste(info, collapse = "; ")
  [07:13:16.795]                     if (!has_future) {
  [07:13:16.795]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:13:16.795]                         info)
  [07:13:16.795]                     }
  [07:13:16.795]                     else {
  [07:13:16.795]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:13:16.795]                         info, version)
  [07:13:16.795]                     }
  [07:13:16.795]                     base::stop(msg)
  [07:13:16.795]                   }
  [07:13:16.795]                 })
  [07:13:16.795]             }
  [07:13:16.795]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:13:16.795]         }
  [07:13:16.795]     }
  [07:13:16.795]     if (base::is.na(TRUE)) {
  [07:13:16.795]     }
  [07:13:16.795]     else {
  [07:13:16.795]         if (TRUE) {
  [07:13:16.795]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:13:16.795]                 open = "w")
  [07:13:16.795]         }
  [07:13:16.795]         else {
  [07:13:16.795]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:13:16.795]                 windows = "NUL", "/dev/null"), open = "w")
  [07:13:16.795]         }
  [07:13:16.795]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:13:16.795]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:13:16.795]             base::sink(type = "output", split = FALSE)
  [07:13:16.795]             base::close(...future.stdout)
  [07:13:16.795]         }, add = TRUE)
  [07:13:16.795]     }
  [07:13:16.795]     ...future.frame <- base::sys.nframe()
  [07:13:16.795]     ...future.conditions <- base::list()
  [07:13:16.795]     ...future.rng <- base::globalenv()$.Random.seed
  [07:13:16.795]     ...future.result <- base::tryCatch({
  [07:13:16.795]         base::withCallingHandlers({
  [07:13:16.795]             ...future.value <- base::withVisible(base::local({
  [07:13:16.795]                 2 * a
  [07:13:16.795]             }))
  [07:13:16.795]             future::FutureResult(value = ...future.value$value, 
  [07:13:16.795]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.795]                   ...future.rng), started = ...future.startTime, 
  [07:13:16.795]                 version = "1.8")
  [07:13:16.795]         }, condition = base::local({
  [07:13:16.795]             c <- base::c
  [07:13:16.795]             inherits <- base::inherits
  [07:13:16.795]             invokeRestart <- base::invokeRestart
  [07:13:16.795]             length <- base::length
  [07:13:16.795]             list <- base::list
  [07:13:16.795]             seq.int <- base::seq.int
  [07:13:16.795]             signalCondition <- base::signalCondition
  [07:13:16.795]             sys.calls <- base::sys.calls
  [07:13:16.795]             Sys.time <- base::Sys.time
  [07:13:16.795]             `[[` <- base::`[[`
  [07:13:16.795]             `+` <- base::`+`
  [07:13:16.795]             `<<-` <- base::`<<-`
  [07:13:16.795]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:13:16.795]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:13:16.795]                   3L)]
  [07:13:16.795]             }
  [07:13:16.795]             function(cond) {
  [07:13:16.795]                 if (inherits(cond, "error")) {
  [07:13:16.795]                   sessionInformation <- function() {
  [07:13:16.795]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:13:16.795]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:13:16.795]                       search = base::search(), system = base::Sys.info())
  [07:13:16.795]                   }
  [07:13:16.795]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.795]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:13:16.795]                     cond$call), session = sessionInformation(), 
  [07:13:16.795]                     timestamp = Sys.time(), signaled = 0L)
  [07:13:16.795]                   signalCondition(cond)
  [07:13:16.795]                 }
  [07:13:16.795]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:13:16.795]                 ))) {
  [07:13:16.795]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:13:16.795]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.795]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:13:16.795]                   if (!signal) {
  [07:13:16.795]                     muffleCondition <- function (cond) 
  [07:13:16.795]                     {
  [07:13:16.795]                       inherits <- base::inherits
  [07:13:16.795]                       invokeRestart <- base::invokeRestart
  [07:13:16.795]                       muffled <- FALSE
  [07:13:16.795]                       if (inherits(cond, "message")) {
  [07:13:16.795]                         invokeRestart("muffleMessage")
  [07:13:16.795]                         muffled <- TRUE
  [07:13:16.795]                       }
  [07:13:16.795]                       else if (inherits(cond, "warning")) {
  [07:13:16.795]                         invokeRestart("muffleWarning")
  [07:13:16.795]                         muffled <- TRUE
  [07:13:16.795]                       }
  [07:13:16.795]                       else if (inherits(cond, "condition")) {
  [07:13:16.795]                         computeRestarts <- base::computeRestarts
  [07:13:16.795]                         grepl <- base::grepl
  [07:13:16.795]                         is.null <- base::is.null
  [07:13:16.795]                         restarts <- computeRestarts(cond)
  [07:13:16.795]                         for (restart in restarts) {
  [07:13:16.795]                           name <- restart$name
  [07:13:16.795]                           if (is.null(name)) 
  [07:13:16.795]                             next
  [07:13:16.795]                           if (!grepl("^muffle", name)) 
  [07:13:16.795]                             next
  [07:13:16.795]                           invokeRestart(restart)
  [07:13:16.795]                           muffled <- TRUE
  [07:13:16.795]                           break
  [07:13:16.795]                         }
  [07:13:16.795]                       }
  [07:13:16.795]                       invisible(muffled)
  [07:13:16.795]                     }
  [07:13:16.795]                     muffleCondition(cond)
  [07:13:16.795]                   }
  [07:13:16.795]                 }
  [07:13:16.795]             }
  [07:13:16.795]         }))
  [07:13:16.795]     }, error = function(ex) {
  [07:13:16.795]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:13:16.795]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.795]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:13:16.795]     }, finally = {
  [07:13:16.795]         {
  [07:13:16.795]             NULL
  [07:13:16.795]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:13:16.795]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:13:16.795]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:13:16.795]                 label = NULL, ...) 
  [07:13:16.795]             {
  [07:13:16.795]                 if (substitute) 
  [07:13:16.795]                   expr <- substitute(expr)
  [07:13:16.795]                 local <- as.logical(local)
  [07:13:16.795]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:13:16.795]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:13:16.795]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:13:16.795]                   label = label, ...)
  [07:13:16.795]                 if (!future$lazy) 
  [07:13:16.795]                   future <- run(future)
  [07:13:16.795]                 invisible(future)
  [07:13:16.795]             }), .cleanup = FALSE, .init = FALSE)
  [07:13:16.795]         }
  [07:13:16.795]         base::options(...future.oldOptions)
  [07:13:16.795]     })
  [07:13:16.795]     Sys.time
  [07:13:16.795]     if (base::is.na(TRUE)) {
  [07:13:16.795]     }
  [07:13:16.795]     else {
  [07:13:16.795]         base::sink(type = "output", split = FALSE)
  [07:13:16.795]         if (TRUE) {
  [07:13:16.795]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:13:16.795]         }
  [07:13:16.795]         else {
  [07:13:16.795]             ...future.result["stdout"] <- base::list(NULL)
  [07:13:16.795]         }
  [07:13:16.795]         base::close(...future.stdout)
  [07:13:16.795]         ...future.stdout <- NULL
  [07:13:16.795]     }
  [07:13:16.795]     ...future.result$conditions <- ...future.conditions
  [07:13:16.795]     ...future.result
  [07:13:16.795] }
  [07:13:16.800] plan(): Setting new future strategy stack:
  [07:13:16.800] List of future strategies:
  [07:13:16.800] 1. sequential:
  [07:13:16.800]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.800]    - tweaked: FALSE
  [07:13:16.800]    - call: NULL
  [07:13:16.801] plan(): nbrOfWorkers() = 1
  [07:13:16.802] plan(): Setting new future strategy stack:
  [07:13:16.802] List of future strategies:
  [07:13:16.802] 1. sequential:
  [07:13:16.802]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.802]    - tweaked: FALSE
  [07:13:16.802]    - call: plan(strategy)
  [07:13:16.803] plan(): nbrOfWorkers() = 1
  [07:13:16.804] SequentialFuture started (and completed)
  [07:13:16.805] getGlobalsAndPackages() ...
  [07:13:16.805] Searching for globals...
  [07:13:16.807] - globals found: [3] '{', '*', 'a'
  [07:13:16.807] Searching for globals ... DONE
  [07:13:16.807] Resolving globals: FALSE
  [07:13:16.808] The total size of the 1 globals is 56 bytes (56 bytes)
  [07:13:16.809] - globals: [1] 'a'
  [07:13:16.809] 
  [07:13:16.809] getGlobalsAndPackages() ... DONE
  [07:13:16.811] Packages needed by the future expression (n = 0): <none>
  [07:13:16.811] Packages needed by future strategies (n = 0): <none>
  [07:13:16.815] {
  [07:13:16.815]     {
  [07:13:16.815]         ...future.startTime <- base::Sys.time()
  [07:13:16.815]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:13:16.815]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:13:16.815]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:13:16.815]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:13:16.815]             future.resolve.recursive = NULL, width = 80L)
  [07:13:16.815]         {
  [07:13:16.815]             {
  [07:13:16.815]                 base::local({
  [07:13:16.815]                   has_future <- base::requireNamespace("future", 
  [07:13:16.815]                     quietly = TRUE)
  [07:13:16.815]                   version <- if (has_future) 
  [07:13:16.815]                     utils::packageVersion("future")
  [07:13:16.815]                   else NULL
  [07:13:16.815]                   if (!has_future || version < "1.8.0") {
  [07:13:16.815]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:13:16.815]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:13:16.815]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:13:16.815]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:13:16.815]                         "release", "version")], collapse = " "), 
  [07:13:16.815]                       hostname = base::Sys.info()[["nodename"]])
  [07:13:16.815]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:13:16.815]                       info)
  [07:13:16.815]                     info <- base::paste(info, collapse = "; ")
  [07:13:16.815]                     if (!has_future) {
  [07:13:16.815]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:13:16.815]                         info)
  [07:13:16.815]                     }
  [07:13:16.815]                     else {
  [07:13:16.815]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:13:16.815]                         info, version)
  [07:13:16.815]                     }
  [07:13:16.815]                     base::stop(msg)
  [07:13:16.815]                   }
  [07:13:16.815]                 })
  [07:13:16.815]             }
  [07:13:16.815]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:13:16.815]         }
  [07:13:16.815]     }
  [07:13:16.815]     if (base::is.na(TRUE)) {
  [07:13:16.815]     }
  [07:13:16.815]     else {
  [07:13:16.815]         if (TRUE) {
  [07:13:16.815]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:13:16.815]                 open = "w")
  [07:13:16.815]         }
  [07:13:16.815]         else {
  [07:13:16.815]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:13:16.815]                 windows = "NUL", "/dev/null"), open = "w")
  [07:13:16.815]         }
  [07:13:16.815]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:13:16.815]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:13:16.815]             base::sink(type = "output", split = FALSE)
  [07:13:16.815]             base::close(...future.stdout)
  [07:13:16.815]         }, add = TRUE)
  [07:13:16.815]     }
  [07:13:16.815]     ...future.frame <- base::sys.nframe()
  [07:13:16.815]     ...future.conditions <- base::list()
  [07:13:16.815]     ...future.rng <- base::globalenv()$.Random.seed
  [07:13:16.815]     ...future.result <- base::tryCatch({
  [07:13:16.815]         base::withCallingHandlers({
  [07:13:16.815]             ...future.value <- base::withVisible(base::local({
  [07:13:16.815]                 2 * a
  [07:13:16.815]             }))
  [07:13:16.815]             future::FutureResult(value = ...future.value$value, 
  [07:13:16.815]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.815]                   ...future.rng), started = ...future.startTime, 
  [07:13:16.815]                 version = "1.8")
  [07:13:16.815]         }, condition = base::local({
  [07:13:16.815]             c <- base::c
  [07:13:16.815]             inherits <- base::inherits
  [07:13:16.815]             invokeRestart <- base::invokeRestart
  [07:13:16.815]             length <- base::length
  [07:13:16.815]             list <- base::list
  [07:13:16.815]             seq.int <- base::seq.int
  [07:13:16.815]             signalCondition <- base::signalCondition
  [07:13:16.815]             sys.calls <- base::sys.calls
  [07:13:16.815]             Sys.time <- base::Sys.time
  [07:13:16.815]             `[[` <- base::`[[`
  [07:13:16.815]             `+` <- base::`+`
  [07:13:16.815]             `<<-` <- base::`<<-`
  [07:13:16.815]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:13:16.815]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:13:16.815]                   3L)]
  [07:13:16.815]             }
  [07:13:16.815]             function(cond) {
  [07:13:16.815]                 if (inherits(cond, "error")) {
  [07:13:16.815]                   sessionInformation <- function() {
  [07:13:16.815]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:13:16.815]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:13:16.815]                       search = base::search(), system = base::Sys.info())
  [07:13:16.815]                   }
  [07:13:16.815]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.815]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:13:16.815]                     cond$call), session = sessionInformation(), 
  [07:13:16.815]                     timestamp = Sys.time(), signaled = 0L)
  [07:13:16.815]                   signalCondition(cond)
  [07:13:16.815]                 }
  [07:13:16.815]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:13:16.815]                 ))) {
  [07:13:16.815]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:13:16.815]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.815]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:13:16.815]                   if (!signal) {
  [07:13:16.815]                     muffleCondition <- function (cond) 
  [07:13:16.815]                     {
  [07:13:16.815]                       inherits <- base::inherits
  [07:13:16.815]                       invokeRestart <- base::invokeRestart
  [07:13:16.815]                       muffled <- FALSE
  [07:13:16.815]                       if (inherits(cond, "message")) {
  [07:13:16.815]                         invokeRestart("muffleMessage")
  [07:13:16.815]                         muffled <- TRUE
  [07:13:16.815]                       }
  [07:13:16.815]                       else if (inherits(cond, "warning")) {
  [07:13:16.815]                         invokeRestart("muffleWarning")
  [07:13:16.815]                         muffled <- TRUE
  [07:13:16.815]                       }
  [07:13:16.815]                       else if (inherits(cond, "condition")) {
  [07:13:16.815]                         computeRestarts <- base::computeRestarts
  [07:13:16.815]                         grepl <- base::grepl
  [07:13:16.815]                         is.null <- base::is.null
  [07:13:16.815]                         restarts <- computeRestarts(cond)
  [07:13:16.815]                         for (restart in restarts) {
  [07:13:16.815]                           name <- restart$name
  [07:13:16.815]                           if (is.null(name)) 
  [07:13:16.815]                             next
  [07:13:16.815]                           if (!grepl("^muffle", name)) 
  [07:13:16.815]                             next
  [07:13:16.815]                           invokeRestart(restart)
  [07:13:16.815]                           muffled <- TRUE
  [07:13:16.815]                           break
  [07:13:16.815]                         }
  [07:13:16.815]                       }
  [07:13:16.815]                       invisible(muffled)
  [07:13:16.815]                     }
  [07:13:16.815]                     muffleCondition(cond)
  [07:13:16.815]                   }
  [07:13:16.815]                 }
  [07:13:16.815]             }
  [07:13:16.815]         }))
  [07:13:16.815]     }, error = function(ex) {
  [07:13:16.815]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:13:16.815]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.815]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:13:16.815]     }, finally = {
  [07:13:16.815]         {
  [07:13:16.815]             NULL
  [07:13:16.815]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:13:16.815]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:13:16.815]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:13:16.815]                 label = NULL, ...) 
  [07:13:16.815]             {
  [07:13:16.815]                 if (substitute) 
  [07:13:16.815]                   expr <- substitute(expr)
  [07:13:16.815]                 local <- as.logical(local)
  [07:13:16.815]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:13:16.815]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:13:16.815]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:13:16.815]                   label = label, ...)
  [07:13:16.815]                 if (!future$lazy) 
  [07:13:16.815]                   future <- run(future)
  [07:13:16.815]                 invisible(future)
  [07:13:16.815]             }), .cleanup = FALSE, .init = FALSE)
  [07:13:16.815]         }
  [07:13:16.815]         base::options(...future.oldOptions)
  [07:13:16.815]     })
  [07:13:16.815]     Sys.time
  [07:13:16.815]     if (base::is.na(TRUE)) {
  [07:13:16.815]     }
  [07:13:16.815]     else {
  [07:13:16.815]         base::sink(type = "output", split = FALSE)
  [07:13:16.815]         if (TRUE) {
  [07:13:16.815]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:13:16.815]         }
  [07:13:16.815]         else {
  [07:13:16.815]             ...future.result["stdout"] <- base::list(NULL)
  [07:13:16.815]         }
  [07:13:16.815]         base::close(...future.stdout)
  [07:13:16.815]         ...future.stdout <- NULL
  [07:13:16.815]     }
  [07:13:16.815]     ...future.result$conditions <- ...future.conditions
  [07:13:16.815]     ...future.result
  [07:13:16.815] }
  [07:13:16.820] plan(): Setting new future strategy stack:
  [07:13:16.820] List of future strategies:
  [07:13:16.820] 1. sequential:
  [07:13:16.820]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.820]    - tweaked: FALSE
  [07:13:16.820]    - call: NULL
  [07:13:16.821] plan(): nbrOfWorkers() = 1
  [07:13:16.822] plan(): Setting new future strategy stack:
  [07:13:16.823] List of future strategies:
  [07:13:16.823] 1. sequential:
  [07:13:16.823]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.823]    - tweaked: FALSE
  [07:13:16.823]    - call: plan(strategy)
  [07:13:16.824] plan(): nbrOfWorkers() = 1
  [07:13:16.824] SequentialFuture started (and completed)
  [07:13:16.825] getGlobalsAndPackages() ...
  [07:13:16.825] Searching for globals...
  [07:13:16.827] - globals found: [3] '{', '*', 'a'
  [07:13:16.827] Searching for globals ... DONE
  [07:13:16.827] Resolving globals: FALSE
  [07:13:16.828] The total size of the 1 globals is 56 bytes (56 bytes)
  [07:13:16.829] - globals: [1] 'a'
  [07:13:16.829] 
  [07:13:16.829] getGlobalsAndPackages() ... DONE
  [07:13:16.831] Packages needed by the future expression (n = 0): <none>
  [07:13:16.831] Packages needed by future strategies (n = 0): <none>
  [07:13:16.835] {
  [07:13:16.835]     {
  [07:13:16.835]         ...future.startTime <- base::Sys.time()
  [07:13:16.835]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:13:16.835]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:13:16.835]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:13:16.835]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:13:16.835]             future.resolve.recursive = NULL, width = 80L)
  [07:13:16.835]         {
  [07:13:16.835]             {
  [07:13:16.835]                 base::local({
  [07:13:16.835]                   has_future <- base::requireNamespace("future", 
  [07:13:16.835]                     quietly = TRUE)
  [07:13:16.835]                   version <- if (has_future) 
  [07:13:16.835]                     utils::packageVersion("future")
  [07:13:16.835]                   else NULL
  [07:13:16.835]                   if (!has_future || version < "1.8.0") {
  [07:13:16.835]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:13:16.835]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:13:16.835]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:13:16.835]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:13:16.835]                         "release", "version")], collapse = " "), 
  [07:13:16.835]                       hostname = base::Sys.info()[["nodename"]])
  [07:13:16.835]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:13:16.835]                       info)
  [07:13:16.835]                     info <- base::paste(info, collapse = "; ")
  [07:13:16.835]                     if (!has_future) {
  [07:13:16.835]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:13:16.835]                         info)
  [07:13:16.835]                     }
  [07:13:16.835]                     else {
  [07:13:16.835]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:13:16.835]                         info, version)
  [07:13:16.835]                     }
  [07:13:16.835]                     base::stop(msg)
  [07:13:16.835]                   }
  [07:13:16.835]                 })
  [07:13:16.835]             }
  [07:13:16.835]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:13:16.835]         }
  [07:13:16.835]     }
  [07:13:16.835]     if (base::is.na(TRUE)) {
  [07:13:16.835]     }
  [07:13:16.835]     else {
  [07:13:16.835]         if (TRUE) {
  [07:13:16.835]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:13:16.835]                 open = "w")
  [07:13:16.835]         }
  [07:13:16.835]         else {
  [07:13:16.835]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:13:16.835]                 windows = "NUL", "/dev/null"), open = "w")
  [07:13:16.835]         }
  [07:13:16.835]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:13:16.835]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:13:16.835]             base::sink(type = "output", split = FALSE)
  [07:13:16.835]             base::close(...future.stdout)
  [07:13:16.835]         }, add = TRUE)
  [07:13:16.835]     }
  [07:13:16.835]     ...future.frame <- base::sys.nframe()
  [07:13:16.835]     ...future.conditions <- base::list()
  [07:13:16.835]     ...future.rng <- base::globalenv()$.Random.seed
  [07:13:16.835]     ...future.result <- base::tryCatch({
  [07:13:16.835]         base::withCallingHandlers({
  [07:13:16.835]             ...future.value <- base::withVisible(base::local({
  [07:13:16.835]                 2 * a
  [07:13:16.835]             }))
  [07:13:16.835]             future::FutureResult(value = ...future.value$value, 
  [07:13:16.835]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.835]                   ...future.rng), started = ...future.startTime, 
  [07:13:16.835]                 version = "1.8")
  [07:13:16.835]         }, condition = base::local({
  [07:13:16.835]             c <- base::c
  [07:13:16.835]             inherits <- base::inherits
  [07:13:16.835]             invokeRestart <- base::invokeRestart
  [07:13:16.835]             length <- base::length
  [07:13:16.835]             list <- base::list
  [07:13:16.835]             seq.int <- base::seq.int
  [07:13:16.835]             signalCondition <- base::signalCondition
  [07:13:16.835]             sys.calls <- base::sys.calls
  [07:13:16.835]             Sys.time <- base::Sys.time
  [07:13:16.835]             `[[` <- base::`[[`
  [07:13:16.835]             `+` <- base::`+`
  [07:13:16.835]             `<<-` <- base::`<<-`
  [07:13:16.835]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:13:16.835]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:13:16.835]                   3L)]
  [07:13:16.835]             }
  [07:13:16.835]             function(cond) {
  [07:13:16.835]                 if (inherits(cond, "error")) {
  [07:13:16.835]                   sessionInformation <- function() {
  [07:13:16.835]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:13:16.835]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:13:16.835]                       search = base::search(), system = base::Sys.info())
  [07:13:16.835]                   }
  [07:13:16.835]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.835]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:13:16.835]                     cond$call), session = sessionInformation(), 
  [07:13:16.835]                     timestamp = Sys.time(), signaled = 0L)
  [07:13:16.835]                   signalCondition(cond)
  [07:13:16.835]                 }
  [07:13:16.835]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:13:16.835]                 ))) {
  [07:13:16.835]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:13:16.835]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.835]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:13:16.835]                   if (!signal) {
  [07:13:16.835]                     muffleCondition <- function (cond) 
  [07:13:16.835]                     {
  [07:13:16.835]                       inherits <- base::inherits
  [07:13:16.835]                       invokeRestart <- base::invokeRestart
  [07:13:16.835]                       muffled <- FALSE
  [07:13:16.835]                       if (inherits(cond, "message")) {
  [07:13:16.835]                         invokeRestart("muffleMessage")
  [07:13:16.835]                         muffled <- TRUE
  [07:13:16.835]                       }
  [07:13:16.835]                       else if (inherits(cond, "warning")) {
  [07:13:16.835]                         invokeRestart("muffleWarning")
  [07:13:16.835]                         muffled <- TRUE
  [07:13:16.835]                       }
  [07:13:16.835]                       else if (inherits(cond, "condition")) {
  [07:13:16.835]                         computeRestarts <- base::computeRestarts
  [07:13:16.835]                         grepl <- base::grepl
  [07:13:16.835]                         is.null <- base::is.null
  [07:13:16.835]                         restarts <- computeRestarts(cond)
  [07:13:16.835]                         for (restart in restarts) {
  [07:13:16.835]                           name <- restart$name
  [07:13:16.835]                           if (is.null(name)) 
  [07:13:16.835]                             next
  [07:13:16.835]                           if (!grepl("^muffle", name)) 
  [07:13:16.835]                             next
  [07:13:16.835]                           invokeRestart(restart)
  [07:13:16.835]                           muffled <- TRUE
  [07:13:16.835]                           break
  [07:13:16.835]                         }
  [07:13:16.835]                       }
  [07:13:16.835]                       invisible(muffled)
  [07:13:16.835]                     }
  [07:13:16.835]                     muffleCondition(cond)
  [07:13:16.835]                   }
  [07:13:16.835]                 }
  [07:13:16.835]             }
  [07:13:16.835]         }))
  [07:13:16.835]     }, error = function(ex) {
  [07:13:16.835]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:13:16.835]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.835]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:13:16.835]     }, finally = {
  [07:13:16.835]         {
  [07:13:16.835]             NULL
  [07:13:16.835]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:13:16.835]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:13:16.835]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:13:16.835]                 label = NULL, ...) 
  [07:13:16.835]             {
  [07:13:16.835]                 if (substitute) 
  [07:13:16.835]                   expr <- substitute(expr)
  [07:13:16.835]                 local <- as.logical(local)
  [07:13:16.835]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:13:16.835]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:13:16.835]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:13:16.835]                   label = label, ...)
  [07:13:16.835]                 if (!future$lazy) 
  [07:13:16.835]                   future <- run(future)
  [07:13:16.835]                 invisible(future)
  [07:13:16.835]             }), .cleanup = FALSE, .init = FALSE)
  [07:13:16.835]         }
  [07:13:16.835]         base::options(...future.oldOptions)
  [07:13:16.835]     })
  [07:13:16.835]     Sys.time
  [07:13:16.835]     if (base::is.na(TRUE)) {
  [07:13:16.835]     }
  [07:13:16.835]     else {
  [07:13:16.835]         base::sink(type = "output", split = FALSE)
  [07:13:16.835]         if (TRUE) {
  [07:13:16.835]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:13:16.835]         }
  [07:13:16.835]         else {
  [07:13:16.835]             ...future.result["stdout"] <- base::list(NULL)
  [07:13:16.835]         }
  [07:13:16.835]         base::close(...future.stdout)
  [07:13:16.835]         ...future.stdout <- NULL
  [07:13:16.835]     }
  [07:13:16.835]     ...future.result$conditions <- ...future.conditions
  [07:13:16.835]     ...future.result
  [07:13:16.835] }
  [07:13:16.840] plan(): Setting new future strategy stack:
  [07:13:16.841] List of future strategies:
  [07:13:16.841] 1. sequential:
  [07:13:16.841]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.841]    - tweaked: FALSE
  [07:13:16.841]    - call: NULL
  [07:13:16.842] plan(): nbrOfWorkers() = 1
  [07:13:16.846] plan(): Setting new future strategy stack:
  [07:13:16.847] List of future strategies:
  [07:13:16.847] 1. sequential:
  [07:13:16.847]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:13:16.847]    - tweaked: FALSE
  [07:13:16.847]    - call: plan(strategy)
  [07:13:16.848] plan(): nbrOfWorkers() = 1
  [07:13:16.848] SequentialFuture started (and completed)
  *** futureAssign() with 'sequential' futures ... DONE
  Testing with 1 cores ... DONE
  Testing with 2 cores ...
  *** futureAssign() with 'multicore' futures ...
  [07:13:16.859] plan(): Setting new future strategy stack:
  [07:13:16.860] List of future strategies:
  [07:13:16.860] 1. multicore:
  [07:13:16.860]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:13:16.860]    - tweaked: FALSE
  [07:13:16.860]    - call: plan(strategy)
  [07:13:16.861] plan(): nbrOfWorkers() = 2
  [07:13:16.862] getGlobalsAndPackages() ...
  [07:13:16.862] Searching for globals...
  [07:13:16.864] - globals found: [1] '{'
  [07:13:16.864] Searching for globals ... DONE
  [07:13:16.864] Resolving globals: FALSE
  [07:13:16.865] 
  [07:13:16.865] 
  [07:13:16.865] getGlobalsAndPackages() ... DONE
  [07:13:16.868] Packages needed by the future expression (n = 0): <none>
  [07:13:16.868] Packages needed by future strategies (n = 0): <none>
  [07:13:16.872] {
  [07:13:16.872]     {
  [07:13:16.872]         ...future.startTime <- base::Sys.time()
  [07:13:16.872]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:13:16.872]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:13:16.872]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:13:16.872]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:13:16.872]             future.resolve.recursive = NULL, width = 80L)
  [07:13:16.872]         {
  [07:13:16.872]             {
  [07:13:16.872]                 {
  [07:13:16.872]                   base::local({
  [07:13:16.872]                     has_future <- base::requireNamespace("future", 
  [07:13:16.872]                       quietly = TRUE)
  [07:13:16.872]                     version <- if (has_future) 
  [07:13:16.872]                       utils::packageVersion("future")
  [07:13:16.872]                     else NULL
  [07:13:16.872]                     if (!has_future || version < "1.8.0") {
  [07:13:16.872]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:13:16.872]                         "", base::R.version$version.string), 
  [07:13:16.872]                         platform = base::sprintf("%s (%s-bit)", 
  [07:13:16.872]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:13:16.872]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:13:16.872]                           "release", "version")], collapse = " "), 
  [07:13:16.872]                         hostname = base::Sys.info()[["nodename"]])
  [07:13:16.872]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:13:16.872]                         info)
  [07:13:16.872]                       info <- base::paste(info, collapse = "; ")
  [07:13:16.872]                       if (!has_future) {
  [07:13:16.872]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:13:16.872]                           info)
  [07:13:16.872]                       }
  [07:13:16.872]                       else {
  [07:13:16.872]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:13:16.872]                           info, version)
  [07:13:16.872]                       }
  [07:13:16.872]                       base::stop(msg)
  [07:13:16.872]                     }
  [07:13:16.872]                   })
  [07:13:16.872]                 }
  [07:13:16.872]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:13:16.872]                 base::options(mc.cores = 1L)
  [07:13:16.872]             }
  [07:13:16.872]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:13:16.872]         }
  [07:13:16.872]     }
  [07:13:16.872]     if (base::is.na(TRUE)) {
  [07:13:16.872]     }
  [07:13:16.872]     else {
  [07:13:16.872]         if (TRUE) {
  [07:13:16.872]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:13:16.872]                 open = "w")
  [07:13:16.872]         }
  [07:13:16.872]         else {
  [07:13:16.872]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:13:16.872]                 windows = "NUL", "/dev/null"), open = "w")
  [07:13:16.872]         }
  [07:13:16.872]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:13:16.872]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:13:16.872]             base::sink(type = "output", split = FALSE)
  [07:13:16.872]             base::close(...future.stdout)
  [07:13:16.872]         }, add = TRUE)
  [07:13:16.872]     }
  [07:13:16.872]     ...future.frame <- base::sys.nframe()
  [07:13:16.872]     ...future.conditions <- base::list()
  [07:13:16.872]     ...future.rng <- base::globalenv()$.Random.seed
  [07:13:16.872]     ...future.result <- base::tryCatch({
  [07:13:16.872]         base::withCallingHandlers({
  [07:13:16.872]             ...future.value <- base::withVisible(base::local({
  [07:13:16.872]                 2
  [07:13:16.872]             }))
  [07:13:16.872]             future::FutureResult(value = ...future.value$value, 
  [07:13:16.872]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.872]                   ...future.rng), started = ...future.startTime, 
  [07:13:16.872]                 version = "1.8")
  [07:13:16.872]         }, condition = base::local({
  [07:13:16.872]             c <- base::c
  [07:13:16.872]             inherits <- base::inherits
  [07:13:16.872]             invokeRestart <- base::invokeRestart
  [07:13:16.872]             length <- base::length
  [07:13:16.872]             list <- base::list
  [07:13:16.872]             seq.int <- base::seq.int
  [07:13:16.872]             signalCondition <- base::signalCondition
  [07:13:16.872]             sys.calls <- base::sys.calls
  [07:13:16.872]             Sys.time <- base::Sys.time
  [07:13:16.872]             `[[` <- base::`[[`
  [07:13:16.872]             `+` <- base::`+`
  [07:13:16.872]             `<<-` <- base::`<<-`
  [07:13:16.872]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:13:16.872]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:13:16.872]                   3L)]
  [07:13:16.872]             }
  [07:13:16.872]             function(cond) {
  [07:13:16.872]                 if (inherits(cond, "error")) {
  [07:13:16.872]                   sessionInformation <- function() {
  [07:13:16.872]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:13:16.872]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:13:16.872]                       search = base::search(), system = base::Sys.info())
  [07:13:16.872]                   }
  [07:13:16.872]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.872]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:13:16.872]                     cond$call), session = sessionInformation(), 
  [07:13:16.872]                     timestamp = Sys.time(), signaled = 0L)
  [07:13:16.872]                   signalCondition(cond)
  [07:13:16.872]                 }
  [07:13:16.872]                 else if (inherits(cond, "condition")) {
  [07:13:16.872]                   signal <- FALSE && inherits(cond, character(0))
  [07:13:16.872]                   ...future.conditions[[length(...future.conditions) + 
  [07:13:16.872]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:13:16.872]                   if (!signal) {
  [07:13:16.872]                     muffleCondition <- function (cond) 
  [07:13:16.872]                     {
  [07:13:16.872]                       inherits <- base::inherits
  [07:13:16.872]                       invokeRestart <- base::invokeRestart
  [07:13:16.872]                       muffled <- FALSE
  [07:13:16.872]                       if (inherits(cond, "message")) {
  [07:13:16.872]                         invokeRestart("muffleMessage")
  [07:13:16.872]                         muffled <- TRUE
  [07:13:16.872]                       }
  [07:13:16.872]                       else if (inherits(cond, "warning")) {
  [07:13:16.872]                         invokeRestart("muffleWarning")
  [07:13:16.872]                         muffled <- TRUE
  [07:13:16.872]                       }
  [07:13:16.872]                       else if (inherits(cond, "condition")) {
  [07:13:16.872]                         computeRestarts <- base::computeRestarts
  [07:13:16.872]                         grepl <- base::grepl
  [07:13:16.872]                         is.null <- base::is.null
  [07:13:16.872]                         restarts <- computeRestarts(cond)
  [07:13:16.872]                         for (restart in restarts) {
  [07:13:16.872]                           name <- restart$name
  [07:13:16.872]                           if (is.null(name)) 
  [07:13:16.872]                             next
  [07:13:16.872]                           if (!grepl("^muffle", name)) 
  [07:13:16.872]                             next
  [07:13:16.872]                           invokeRestart(restart)
  [07:13:16.872]                           muffled <- TRUE
  [07:13:16.872]                           break
  [07:13:16.872]                         }
  [07:13:16.872]                       }
  [07:13:16.872]                       invisible(muffled)
  [07:13:16.872]                     }
  [07:13:16.872]                     muffleCondition(cond)
  [07:13:16.872]                   }
  [07:13:16.872]                 }
  [07:13:16.872]             }
  [07:13:16.872]         }))
  [07:13:16.872]     }, error = function(ex) {
  [07:13:16.872]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:13:16.872]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:13:16.872]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:13:16.872]     }, finally = {
  [07:13:16.872]         {
  [07:13:16.872]             {
  [07:13:16.872]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:13:16.872]             }
  [07:13:16.872]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:13:16.872]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:13:16.872]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:13:16.872]                 earlySignal = FALSE, label = NULL, ...) 
  [07:13:16.872]             {
  [07:13:16.872]                 if (substitute) 
  [07:13:16.872]                   expr <- substitute(expr)
  [07:13:16.872]                 if (is.function(workers)) 
  [07:13:16.872]                   workers <- workers()
  [07:13:16.872]                 workers <- as.integer(workers)
  [07:13:16.872]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:13:16.872]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:13:16.872]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:13:16.872]                     lazy = lazy, seed = seed, globals = globals, 
  [07:13:16.872]                     local = TRUE, label = label, ...))
  [07:13:16.872]                 }
  [07:13:16.872]                 oopts <- options(mc.cores = workers)
  [07:13:16.872]                 on.exit(options(oopts))
  [07:13:16.872]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:13:16.872]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:13:16.872]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:13:16.872]                   label = label, ...)
  [07:13:16.872]                 if (!future$lazy) 
  [07:13:16.872]                   future <- run(future)
  [07:13:16.872]                 invisible(future)
  [07:13:16.872]             }), .cleanup = FALSE, .init = FALSE)
  [07:13:16.872]         }
  [07:13:16.872]         base::options(...future.oldOptions)
  [07:13:16.872]     })
  [07:13:16.872]     Sys.time
  [07:13:16.872]     if (base::is.na(TRUE)) {
  [07:13:16.872]     }
  [07:13:16.872]     else {
  [07:13:16.872]         base::sink(type = "output", split = FALSE)
  [07:13:16.872]         if (TRUE) {
  [07:13:16.872]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:13:16.872]         }
  [07:13:16.872]         else {
  [07:13:16.872]             ...future.result["stdout"] <- base::list(NULL)
  [07:13:16.872]         }
  [07:13:16.872]         base::close(...future.stdout)
  [07:13:16.872]         ...future.stdout <- NULL
  [07:13:16.872]     }
  [07:13:16.872]     ...future.result$conditions <- ...future.conditions
  [07:13:16.872]     ...future.result
  [07:13:16.872] }
  [07:13:16.876] requestCore(): workers = 2
  [07:13:16.882] MulticoreFuture started
  [07:13:16.885] getGlobalsAndPackages() ...
  [07:13:16.886] Searching for globals...
  [07:13:16.886] plan(): Setting new future strategy stack:
  [07:13:16.887] List of future strategies:
  [07:13:16.887] 1. sequential:
  [07:13:16.887]    - args: function (expr, envir = parent.frame(), substitut