Running ‘000.sessionDetails.R’
  Running ‘ClusterRegistry.R’ [1s/122s]
  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’ [5s/126s]
  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’ [3s/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")
  [07:08:26.923] plan(): Setting new future strategy stack:
  [07:08:26.925] List of future strategies:
  [07:08:26.925] 1. sequential:
  [07:08:26.925]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:08:26.925]    - tweaked: FALSE
  [07:08:26.925]    - call: future::plan("sequential")
  [07:08:26.928] 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: 27294
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/data/gannet/ripley/R/R-clang/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpCJXyDX/future.parent=677942.a58364f9fc689.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmpi2dwzg/working_dir/RtmpCJXyDX/future.parent=677942.a58364f9fc689.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/ClusterRegistry.R:gannet.stats.ox.ac.uk:ripley:677942' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpCJXyDX/future.parent=677942.a58364f9fc689.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=27294 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 678053) if still alive
  [07:10:28.037] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(677942, signal = 0L)
  [1] TRUE
  Call: tools::pskill(677942, signal = 0L)
  [1] TRUE
  [07:10:28.038] - success
  [07:10:28.038] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 678053) 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 27294 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/ClusterRegistry.R:gannet.stats.ox.ac.uk:ripley:677942' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpCJXyDX/future.parent=677942.a58364f9fc689.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=27294 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 678053) 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:10:28.396] plan(): Setting new future strategy stack:
  [07:10:28.397] List of future strategies:
  [07:10:28.397] 1. sequential:
  [07:10:28.397]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:10:28.397]    - tweaked: FALSE
  [07:10:28.397]    - call: future::plan("sequential")
  [07:10:28.399] 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: b97aed60-4920-131b-fa4f-08ed33f0958d
  Class: 'Future', 'environment'
  > res <- tryCatch(value(f), error = identity)
  > print(res)
  <simpleError: node stack overflow>
  > 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:10:28.502] plan(): Setting new future strategy stack:
  [07:10:28.503] List of future strategies:
  [07:10:28.503] 1. future:
  [07:10:28.503]    - args: function (...)
  [07:10:28.503]    - tweaked: FALSE
  [07:10:28.503]    - call: plan(foo)
  [07:10:28.534] plan(): nbrOfWorkers() = Inf
  > f <- Future()
  > expr <- getExpression(f)
  [07:10:28.536] Packages needed by the future expression (n = 0): <none>
  [07:10:28.536] Packages needed by future strategies (n = 0): <none>
  [07:10:28.540] {
  [07:10:28.540]     {
  [07:10:28.540]         ...future.startTime <- base::Sys.time()
  [07:10:28.540]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:10:28.540]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:10:28.540]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:10:28.540]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:10:28.540]             future.resolve.recursive = NULL, width = 80L)
  [07:10:28.540]         {
  [07:10:28.540]             {
  [07:10:28.540]                 base::local({
  [07:10:28.540]                   has_future <- base::requireNamespace("future", 
  [07:10:28.540]                     quietly = TRUE)
  [07:10:28.540]                   version <- if (has_future) 
  [07:10:28.540]                     utils::packageVersion("future")
  [07:10:28.540]                   else NULL
  [07:10:28.540]                   if (!has_future || version < "1.8.0") {
  [07:10:28.540]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:10:28.540]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:10:28.540]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:10:28.540]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:10:28.540]                         "release", "version")], collapse = " "), 
  [07:10:28.540]                       hostname = base::Sys.info()[["nodename"]])
  [07:10:28.540]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:10:28.540]                       info)
  [07:10:28.540]                     info <- base::paste(info, collapse = "; ")
  [07:10:28.540]                     if (!has_future) {
  [07:10:28.540]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:10:28.540]                         info)
  [07:10:28.540]                     }
  [07:10:28.540]                     else {
  [07:10:28.540]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:10:28.540]                         info, version)
  [07:10:28.540]                     }
  [07:10:28.540]                     base::stop(msg)
  [07:10:28.540]                   }
  [07:10:28.540]                 })
  [07:10:28.540]             }
  [07:10:28.540]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:10:28.540]         }
  [07:10:28.540]     }
  [07:10:28.540]     if (base::is.na(TRUE)) {
  [07:10:28.540]     }
  [07:10:28.540]     else {
  [07:10:28.540]         if (TRUE) {
  [07:10:28.540]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:10:28.540]                 open = "w")
  [07:10:28.540]         }
  [07:10:28.540]         else {
  [07:10:28.540]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:10:28.540]                 windows = "NUL", "/dev/null"), open = "w")
  [07:10:28.540]         }
  [07:10:28.540]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:10:28.540]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:10:28.540]             base::sink(type = "output", split = FALSE)
  [07:10:28.540]             base::close(...future.stdout)
  [07:10:28.540]         }, add = TRUE)
  [07:10:28.540]     }
  [07:10:28.540]     ...future.frame <- base::sys.nframe()
  [07:10:28.540]     ...future.conditions <- base::list()
  [07:10:28.540]     ...future.rng <- base::globalenv()$.Random.seed
  [07:10:28.540]     ...future.result <- base::tryCatch({
  [07:10:28.540]         base::withCallingHandlers({
  [07:10:28.540]             ...future.value <- base::withVisible(base::local(NULL))
  [07:10:28.540]             future::FutureResult(value = ...future.value$value, 
  [07:10:28.540]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:10:28.540]                   ...future.rng), started = ...future.startTime, 
  [07:10:28.540]                 version = "1.8")
  [07:10:28.540]         }, condition = base::local({
  [07:10:28.540]             c <- base::c
  [07:10:28.540]             inherits <- base::inherits
  [07:10:28.540]             invokeRestart <- base::invokeRestart
  [07:10:28.540]             length <- base::length
  [07:10:28.540]             list <- base::list
  [07:10:28.540]             seq.int <- base::seq.int
  [07:10:28.540]             signalCondition <- base::signalCondition
  [07:10:28.540]             sys.calls <- base::sys.calls
  [07:10:28.540]             Sys.time <- base::Sys.time
  [07:10:28.540]             `[[` <- base::`[[`
  [07:10:28.540]             `+` <- base::`+`
  [07:10:28.540]             `<<-` <- base::`<<-`
  [07:10:28.540]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:10:28.540]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:10:28.540]                   3L)]
  [07:10:28.540]             }
  [07:10:28.540]             function(cond) {
  [07:10:28.540]                 if (inherits(cond, "error")) {
  [07:10:28.540]                   sessionInformation <- function() {
  [07:10:28.540]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:10:28.540]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:10:28.540]                       search = base::search(), system = base::Sys.info())
  [07:10:28.540]                   }
  [07:10:28.540]                   ...future.conditions[[length(...future.conditions) + 
  [07:10:28.540]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:10:28.540]                     cond$call), session = sessionInformation(), 
  [07:10:28.540]                     timestamp = Sys.time(), signaled = 0L)
  [07:10:28.540]                   signalCondition(cond)
  [07:10:28.540]                 }
  [07:10:28.540]                 else if (inherits(cond, "condition")) {
  [07:10:28.540]                   signal <- FALSE && inherits(cond, character(0))
  [07:10:28.540]                   ...future.conditions[[length(...future.conditions) + 
  [07:10:28.540]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:10:28.540]                   if (!signal) {
  [07:10:28.540]                     muffleCondition <- function (cond) 
  [07:10:28.540]                     {
  [07:10:28.540]                       inherits <- base::inherits
  [07:10:28.540]                       invokeRestart <- base::invokeRestart
  [07:10:28.540]                       muffled <- FALSE
  [07:10:28.540]                       if (inherits(cond, "message")) {
  [07:10:28.540]                         invokeRestart("muffleMessage")
  [07:10:28.540]                         muffled <- TRUE
  [07:10:28.540]                       }
  [07:10:28.540]                       else if (inherits(cond, "warning")) {
  [07:10:28.540]                         invokeRestart("muffleWarning")
  [07:10:28.540]                         muffled <- TRUE
  [07:10:28.540]                       }
  [07:10:28.540]                       else if (inherits(cond, "condition")) {
  [07:10:28.540]                         computeRestarts <- base::computeRestarts
  [07:10:28.540]                         grepl <- base::grepl
  [07:10:28.540]                         is.null <- base::is.null
  [07:10:28.540]                         restarts <- computeRestarts(cond)
  [07:10:28.540]                         for (restart in restarts) {
  [07:10:28.540]                           name <- restart$name
  [07:10:28.540]                           if (is.null(name)) 
  [07:10:28.540]                             next
  [07:10:28.540]                           if (!grepl("^muffle", name)) 
  [07:10:28.540]                             next
  [07:10:28.540]                           invokeRestart(restart)
  [07:10:28.540]                           muffled <- TRUE
  [07:10:28.540]                           break
  [07:10:28.540]                         }
  [07:10:28.540]                       }
  [07:10:28.540]                       invisible(muffled)
  [07:10:28.540]                     }
  [07:10:28.540]                     muffleCondition(cond)
  [07:10:28.540]                   }
  [07:10:28.540]                 }
  [07:10:28.540]             }
  [07:10:28.540]         }))
  [07:10:28.540]     }, error = function(ex) {
  [07:10:28.540]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:10:28.540]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:10:28.540]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:10:28.540]     }, finally = {
  [07:10:28.540]         {
  [07:10:28.540]             NULL
  [07:10:28.540]             future::plan(list(function (...) 
  [07:10:28.540]             {
  [07:10:28.540]                 Future(1)
  [07:10:28.540]             }), .cleanup = FALSE, .init = FALSE)
  [07:10:28.540]         }
  [07:10:28.540]         base::options(...future.oldOptions)
  [07:10:28.540]     })
  [07:10:28.540]     Sys.time
  [07:10:28.540]     if (base::is.na(TRUE)) {
  [07:10:28.540]     }
  [07:10:28.540]     else {
  [07:10:28.540]         base::sink(type = "output", split = FALSE)
  [07:10:28.540]         if (TRUE) {
  [07:10:28.540]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:10:28.540]         }
  [07:10:28.540]         else {
  [07:10:28.540]             ...future.result["stdout"] <- base::list(NULL)
  [07:10:28.540]         }
  [07:10:28.540]         base::close(...future.stdout)
  [07:10:28.540]         ...future.stdout <- NULL
  [07:10:28.540]     }
  [07:10:28.540]     ...future.result$conditions <- ...future.conditions
  [07:10:28.540]     ...future.result
  [07:10:28.540] }
  > 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:10:28.564] getGlobalsAndPackages() ...
  [07:10:28.564] Searching for globals...
  [07:10:28.568] 
  [07:10:28.568] Searching for globals ... DONE
  [07:10:28.568] - globals: [0] <none>
  [07:10:28.568] 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: b97aed60-4920-131b-fa4f-08ed33f0958d
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [07:10:28.571] Packages needed by the future expression (n = 0): <none>
  [07:10:28.571] Packages needed by future strategies (n = 0): <none>
  [07:10:28.575] {
  [07:10:28.575]     {
  [07:10:28.575]         ...future.startTime <- base::Sys.time()
  [07:10:28.575]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:10:28.575]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:10:28.575]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:10:28.575]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:10:28.575]             future.resolve.recursive = NULL, width = 80L)
  [07:10:28.575]         {
  [07:10:28.575]             {
  [07:10:28.575]                 base::local({
  [07:10:28.575]                   has_future <- base::requireNamespace("future", 
  [07:10:28.575]                     quietly = TRUE)
  [07:10:28.575]                   version <- if (has_future) 
  [07:10:28.575]                     utils::packageVersion("future")
  [07:10:28.575]                   else NULL
  [07:10:28.575]                   if (!has_future || version < "1.8.0") {
  [07:10:28.575]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:10:28.575]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:10:28.575]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:10:28.575]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:10:28.575]                         "release", "version")], collapse = " "), 
  [07:10:28.575]                       hostname = base::Sys.info()[["nodename"]])
  [07:10:28.575]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:10:28.575]                       info)
  [07:10:28.575]                     info <- base::paste(info, collapse = "; ")
  [07:10:28.575]                     if (!has_future) {
  [07:10:28.575]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:10:28.575]                         info)
  [07:10:28.575]                     }
  [07:10:28.575]                     else {
  [07:10:28.575]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:10:28.575]                         info, version)
  [07:10:28.575]                     }
  [07:10:28.575]                     base::stop(msg)
  [07:10:28.575]                   }
  [07:10:28.575]                 })
  [07:10:28.575]             }
  [07:10:28.575]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:10:28.575]         }
  [07:10:28.575]     }
  [07:10:28.575]     if (base::is.na(TRUE)) {
  [07:10:28.575]     }
  [07:10:28.575]     else {
  [07:10:28.575]         if (TRUE) {
  [07:10:28.575]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:10:28.575]                 open = "w")
  [07:10:28.575]         }
  [07:10:28.575]         else {
  [07:10:28.575]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:10:28.575]                 windows = "NUL", "/dev/null"), open = "w")
  [07:10:28.575]         }
  [07:10:28.575]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:10:28.575]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:10:28.575]             base::sink(type = "output", split = FALSE)
  [07:10:28.575]             base::close(...future.stdout)
  [07:10:28.575]         }, add = TRUE)
  [07:10:28.575]     }
  [07:10:28.575]     ...future.frame <- base::sys.nframe()
  [07:10:28.575]     ...future.conditions <- base::list()
  [07:10:28.575]     ...future.rng <- base::globalenv()$.Random.seed
  [07:10:28.575]     ...future.result <- base::tryCatch({
  [07:10:28.575]         base::withCallingHandlers({
  [07:10:28.575]             ...future.value <- base::withVisible(base::local(42L))
  [07:10:28.575]             future::FutureResult(value = ...future.value$value, 
  [07:10:28.575]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:10:28.575]                   ...future.rng), started = ...future.startTime, 
  [07:10:28.575]                 version = "1.8")
  [07:10:28.575]         }, condition = base::local({
  [07:10:28.575]             c <- base::c
  [07:10:28.575]             inherits <- base::inherits
  [07:10:28.575]             invokeRestart <- base::invokeRestart
  [07:10:28.575]             length <- base::length
  [07:10:28.575]             list <- base::list
  [07:10:28.575]             seq.int <- base::seq.int
  [07:10:28.575]             signalCondition <- base::signalCondition
  [07:10:28.575]             sys.calls <- base::sys.calls
  [07:10:28.575]             Sys.time <- base::Sys.time
  [07:10:28.575]             `[[` <- base::`[[`
  [07:10:28.575]             `+` <- base::`+`
  [07:10:28.575]             `<<-` <- base::`<<-`
  [07:10:28.575]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:10:28.575]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:10:28.575]                   3L)]
  [07:10:28.575]             }
  [07:10:28.575]             function(cond) {
  [07:10:28.575]                 if (inherits(cond, "error")) {
  [07:10:28.575]                   sessionInformation <- function() {
  [07:10:28.575]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:10:28.575]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:10:28.575]                       search = base::search(), system = base::Sys.info())
  [07:10:28.575]                   }
  [07:10:28.575]                   ...future.conditions[[length(...future.conditions) + 
  [07:10:28.575]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:10:28.575]                     cond$call), session = sessionInformation(), 
  [07:10:28.575]                     timestamp = Sys.time(), signaled = 0L)
  [07:10:28.575]                   signalCondition(cond)
  [07:10:28.575]                 }
  [07:10:28.575]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:10:28.575]                 ))) {
  [07:10:28.575]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:10:28.575]                   ...future.conditions[[length(...future.conditions) + 
  [07:10:28.575]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:10:28.575]                   if (!signal) {
  [07:10:28.575]                     muffleCondition <- function (cond) 
  [07:10:28.575]                     {
  [07:10:28.575]                       inherits <- base::inherits
  [07:10:28.575]                       invokeRestart <- base::invokeRestart
  [07:10:28.575]                       muffled <- FALSE
  [07:10:28.575]                       if (inherits(cond, "message")) {
  [07:10:28.575]                         invokeRestart("muffleMessage")
  [07:10:28.575]                         muffled <- TRUE
  [07:10:28.575]                       }
  [07:10:28.575]                       else if (inherits(cond, "warning")) {
  [07:10:28.575]                         invokeRestart("muffleWarning")
  [07:10:28.575]                         muffled <- TRUE
  [07:10:28.575]                       }
  [07:10:28.575]                       else if (inherits(cond, "condition")) {
  [07:10:28.575]                         computeRestarts <- base::computeRestarts
  [07:10:28.575]                         grepl <- base::grepl
  [07:10:28.575]                         is.null <- base::is.null
  [07:10:28.575]                         restarts <- computeRestarts(cond)
  [07:10:28.575]                         for (restart in restarts) {
  [07:10:28.575]                           name <- restart$name
  [07:10:28.575]                           if (is.null(name)) 
  [07:10:28.575]                             next
  [07:10:28.575]                           if (!grepl("^muffle", name)) 
  [07:10:28.575]                             next
  [07:10:28.575]                           invokeRestart(restart)
  [07:10:28.575]                           muffled <- TRUE
  [07:10:28.575]                           break
  [07:10:28.575]                         }
  [07:10:28.575]                       }
  [07:10:28.575]                       invisible(muffled)
  [07:10:28.575]                     }
  [07:10:28.575]                     muffleCondition(cond)
  [07:10:28.575]                   }
  [07:10:28.575]                 }
  [07:10:28.575]             }
  [07:10:28.575]         }))
  [07:10:28.575]     }, error = function(ex) {
  [07:10:28.575]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:10:28.575]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:10:28.575]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:10:28.575]     }, finally = {
  [07:10:28.575]         {
  [07:10:28.575]             NULL
  [07:10:28.575]             future::plan(list(function (...) 
  [07:10:28.575]             {
  [07:10:28.575]                 Future(1)
  [07:10:28.575]             }), .cleanup = FALSE, .init = FALSE)
  [07:10:28.575]         }
  [07:10:28.575]         base::options(...future.oldOptions)
  [07:10:28.575]     })
  [07:10:28.575]     Sys.time
  [07:10:28.575]     if (base::is.na(TRUE)) {
  [07:10:28.575]     }
  [07:10:28.575]     else {
  [07:10:28.575]         base::sink(type = "output", split = FALSE)
  [07:10:28.575]         if (TRUE) {
  [07:10:28.575]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:10:28.575]         }
  [07:10:28.575]         else {
  [07:10:28.575]             ...future.result["stdout"] <- base::list(NULL)
  [07:10:28.575]         }
  [07:10:28.575]         base::close(...future.stdout)
  [07:10:28.575]         ...future.stdout <- NULL
  [07:10:28.575]     }
  [07:10:28.575]     ...future.result$conditions <- ...future.conditions
  [07:10:28.575]     ...future.result
  [07:10:28.575] }
  [07:10:28.579] plan(): Setting new future strategy stack:
  [07:10:28.580] List of future strategies:
  [07:10:28.580] 1. sequential:
  [07:10:28.580]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:10:28.580]    - tweaked: FALSE
  [07:10:28.580]    - call: NULL
  [07:10:28.580] plan(): nbrOfWorkers() = 1
  [07:10:28.582] plan(): Setting new future strategy stack:
  [07:10:28.582] List of future strategies:
  [07:10:28.582] 1. future:
  [07:10:28.582]    - args: function (...)
  [07:10:28.582]    - tweaked: FALSE
  [07:10:28.582]    - call: plan(foo)
  [07:10:28.583] plan(): nbrOfWorkers() = Inf
  [07:10:28.583] SequentialFuture started (and completed)
  [1] 42
  [07:10:28.584] getGlobalsAndPackages() ...
  [07:10:28.585] Searching for globals...
  [07:10:28.585] 
  [07:10:28.586] Searching for globals ... DONE
  [07:10:28.586] - globals: [0] <none>
  [07:10:28.586] getGlobalsAndPackages() ... DONE
  [07:10:28.587] Packages needed by the future expression (n = 0): <none>
  [07:10:28.588] Packages needed by future strategies (n = 0): <none>
  [07:10:28.591] {
  [07:10:28.591]     {
  [07:10:28.591]         ...future.startTime <- base::Sys.time()
  [07:10:28.591]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:10:28.591]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:10:28.591]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:10:28.591]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:10:28.591]             future.resolve.recursive = NULL, width = 80L)
  [07:10:28.591]         {
  [07:10:28.591]             {
  [07:10:28.591]                 base::local({
  [07:10:28.591]                   has_future <- base::requireNamespace("future", 
  [07:10:28.591]                     quietly = TRUE)
  [07:10:28.591]                   version <- if (has_future) 
  [07:10:28.591]                     utils::packageVersion("future")
  [07:10:28.591]                   else NULL
  [07:10:28.591]                   if (!has_future || version < "1.8.0") {
  [07:10:28.591]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:10:28.591]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:10:28.591]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:10:28.591]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:10:28.591]                         "release", "version")], collapse = " "), 
  [07:10:28.591]                       hostname = base::Sys.info()[["nodename"]])
  [07:10:28.591]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:10:28.591]                       info)
  [07:10:28.591]                     info <- base::paste(info, collapse = "; ")
  [07:10:28.591]                     if (!has_future) {
  [07:10:28.591]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:10:28.591]                         info)
  [07:10:28.591]                     }
  [07:10:28.591]                     else {
  [07:10:28.591]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:10:28.591]                         info, version)
  [07:10:28.591]                     }
  [07:10:28.591]                     base::stop(msg)
  [07:10:28.591]                   }
  [07:10:28.591]                 })
  [07:10:28.591]             }
  [07:10:28.591]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:10:28.591]         }
  [07:10:28.591]     }
  [07:10:28.591]     if (base::is.na(TRUE)) {
  [07:10:28.591]     }
  [07:10:28.591]     else {
  [07:10:28.591]         if (TRUE) {
  [07:10:28.591]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:10:28.591]                 open = "w")
  [07:10:28.591]         }
  [07:10:28.591]         else {
  [07:10:28.591]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:10:28.591]                 windows = "NUL", "/dev/null"), open = "w")
  [07:10:28.591]         }
  [07:10:28.591]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:10:28.591]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:10:28.591]             base::sink(type = "output", split = FALSE)
  [07:10:28.591]             base::close(...future.stdout)
  [07:10:28.591]         }, add = TRUE)
  [07:10:28.591]     }
  [07:10:28.591]     ...future.frame <- base::sys.nframe()
  [07:10:28.591]     ...future.conditions <- base::list()
  [07:10:28.591]     ...future.rng <- base::globalenv()$.Random.seed
  [07:10:28.591]     ...future.result <- base::tryCatch({
  [07:10:28.591]         base::withCallingHandlers({
  [07:10:28.591]             ...future.value <- base::withVisible(base::local(42L))
  [07:10:28.591]             future::FutureResult(value = ...future.value$value, 
  [07:10:28.591]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:10:28.591]                   ...future.rng), started = ...future.startTime, 
  [07:10:28.591]                 version = "1.8")
  [07:10:28.591]         }, condition = base::local({
  [07:10:28.591]             c <- base::c
  [07:10:28.591]             inherits <- base::inherits
  [07:10:28.591]             invokeRestart <- base::invokeRestart
  [07:10:28.591]             length <- base::length
  [07:10:28.591]             list <- base::list
  [07:10:28.591]             seq.int <- base::seq.int
  [07:10:28.591]             signalCondition <- base::signalCondition
  [07:10:28.591]             sys.calls <- base::sys.calls
  [07:10:28.591]             Sys.time <- base::Sys.time
  [07:10:28.591]             `[[` <- base::`[[`
  [07:10:28.591]             `+` <- base::`+`
  [07:10:28.591]             `<<-` <- base::`<<-`
  [07:10:28.591]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:10:28.591]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:10:28.591]                   3L)]
  [07:10:28.591]             }
  [07:10:28.591]             function(cond) {
  [07:10:28.591]                 if (inherits(cond, "error")) {
  [07:10:28.591]                   sessionInformation <- function() {
  [07:10:28.591]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:10:28.591]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:10:28.591]                       search = base::search(), system = base::Sys.info())
  [07:10:28.591]                   }
  [07:10:28.591]                   ...future.conditions[[length(...future.conditions) + 
  [07:10:28.591]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:10:28.591]                     cond$call), session = sessionInformation(), 
  [07:10:28.591]                     timestamp = Sys.time(), signaled = 0L)
  [07:10:28.591]                   signalCondition(cond)
  [07:10:28.591]                 }
  [07:10:28.591]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:10:28.591]                 ))) {
  [07:10:28.591]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:10:28.591]                   ...future.conditions[[length(...future.conditions) + 
  [07:10:28.591]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:10:28.591]                   if (!signal) {
  [07:10:28.591]                     muffleCondition <- function (cond) 
  [07:10:28.591]                     {
  [07:10:28.591]                       inherits <- base::inherits
  [07:10:28.591]                       invokeRestart <- base::invokeRestart
  [07:10:28.591]                       muffled <- FALSE
  [07:10:28.591]                       if (inherits(cond, "message")) {
  [07:10:28.591]                         invokeRestart("muffleMessage")
  [07:10:28.591]                         muffled <- TRUE
  [07:10:28.591]                       }
  [07:10:28.591]                       else if (inherits(cond, "warning")) {
  [07:10:28.591]                         invokeRestart("muffleWarning")
  [07:10:28.591]                         muffled <- TRUE
  [07:10:28.591]                       }
  [07:10:28.591]                       else if (inherits(cond, "condition")) {
  [07:10:28.591]                         computeRestarts <- base::computeRestarts
  [07:10:28.591]                         grepl <- base::grepl
  [07:10:28.591]                         is.null <- base::is.null
  [07:10:28.591]                         restarts <- computeRestarts(cond)
  [07:10:28.591]                         for (restart in restarts) {
  [07:10:28.591]                           name <- restart$name
  [07:10:28.591]                           if (is.null(name)) 
  [07:10:28.591]                             next
  [07:10:28.591]                           if (!grepl("^muffle", name)) 
  [07:10:28.591]                             next
  [07:10:28.591]                           invokeRestart(restart)
  [07:10:28.591]                           muffled <- TRUE
  [07:10:28.591]                           break
  [07:10:28.591]                         }
  [07:10:28.591]                       }
  [07:10:28.591]                       invisible(muffled)
  [07:10:28.591]                     }
  [07:10:28.591]                     muffleCondition(cond)
  [07:10:28.591]                   }
  [07:10:28.591]                 }
  [07:10:28.591]             }
  [07:10:28.591]         }))
  [07:10:28.591]     }, error = function(ex) {
  [07:10:28.591]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:10:28.591]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:10:28.591]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:10:28.591]     }, finally = {
  [07:10:28.591]         {
  [07:10:28.591]             NULL
  [07:10:28.591]             future::plan(list(function (...) 
  [07:10:28.591]             {
  [07:10:28.591]                 Future(1)
  [07:10:28.591]             }), .cleanup = FALSE, .init = FALSE)
  [07:10:28.591]         }
  [07:10:28.591]         base::options(...future.oldOptions)
  [07:10:28.591]     })
  [07:10:28.591]     Sys.time
  [07:10:28.591]     if (base::is.na(TRUE)) {
  [07:10:28.591]     }
  [07:10:28.591]     else {
  [07:10:28.591]         base::sink(type = "output", split = FALSE)
  [07:10:28.591]         if (TRUE) {
  [07:10:28.591]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:10:28.591]         }
  [07:10:28.591]         else {
  [07:10:28.591]             ...future.result["stdout"] <- base::list(NULL)
  [07:10:28.591]         }
  [07:10:28.591]         base::close(...future.stdout)
  [07:10:28.591]         ...future.stdout <- NULL
  [07:10:28.591]     }
  [07:10:28.591]     ...future.result$conditions <- ...future.conditions
  [07:10:28.591]     ...future.result
  [07:10:28.591] }
  [07:10:28.595] plan(): Setting new future strategy stack:
  [07:10:28.596] List of future strategies:
  [07:10:28.596] 1. sequential:
  [07:10:28.596]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:10:28.596]    - tweaked: FALSE
  [07:10:28.596]    - call: NULL
  [07:10:28.596] plan(): nbrOfWorkers() = 1
  [07:10:28.597] plan(): Setting new future strategy stack:
  [07:10:28.598] List of future strategies:
  [07:10:28.598] 1. future:
  [07:10:28.598]    - args: function (...)
  [07:10:28.598]    - tweaked: FALSE
  [07:10:28.598]    - call: plan(foo)
  [07:10:28.598] plan(): nbrOfWorkers() = Inf
  [07:10:28.599] SequentialFuture started (and completed)
  [1] 42
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 23699
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/data/gannet/ripley/R/R-clang/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpgLUGNC/future.parent=691056.a8b704d8eecd9.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmpi2dwzg/working_dir/RtmpgLUGNC/future.parent=691056.a8b704d8eecd9.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/Future-class.R:gannet.stats.ox.ac.uk:ripley:691056' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpgLUGNC/future.parent=691056.a8b704d8eecd9.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=23699 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 691104) if still alive
  [07:12:29.429] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(691056, signal = 0L)
  [1] TRUE
  Call: tools::pskill(691056, signal = 0L)
  [1] TRUE
  [07:12:29.430] - success
  [07:12:29.431] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 691104) 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 23699 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/Future-class.R:gannet.stats.ox.ac.uk:ripley:691056' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpgLUGNC/future.parent=691056.a8b704d8eecd9.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=23699 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 691104) 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:12:31.193] plan(): Setting new future strategy stack:
  [07:12:31.194] List of future strategies:
  [07:12:31.194] 1. sequential:
  [07:12:31.194]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:12:31.194]    - tweaked: FALSE
  [07:12:31.194]    - call: future::plan("sequential")
  [07:12:31.196] 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: 22279
  [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-clang/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpYTmCea/future.parent=694978.a9ac2370d94f5.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmpi2dwzg/working_dir/RtmpYTmCea/future.parent=694978.a9ac2370d94f5.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/as.cluster.R:gannet.stats.ox.ac.uk:ripley:694978' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpYTmCea/future.parent=694978.a9ac2370d94f5.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=22279 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 695011) if still alive
  [07:14:32.037] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(694978, signal = 0L)
  [1] TRUE
  Call: tools::pskill(694978, signal = 0L)
  [1] TRUE
  [07:14:32.039] - success
  [07:14:32.039] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 695011) 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 22279 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/as.cluster.R:gannet.stats.ox.ac.uk:ripley:694978' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpYTmCea/future.parent=694978.a9ac2370d94f5.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=22279 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 695011) 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:14:35.278] plan(): Setting new future strategy stack:
  [07:14:35.279] List of future strategies:
  [07:14:35.279] 1. sequential:
  [07:14:35.279]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:14:35.279]    - tweaked: FALSE
  [07:14:35.279]    - call: future::plan("sequential")
  [07:14:35.280] plan(): nbrOfWorkers() = 1
  > library("listenv")
  > options(future.debug = FALSE)
  > message("*** cluster() ...")
  *** cluster() ...
  > 
  > message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
  Library paths: '/tmp/Rtmpi2dwzg/RLIBS_a267a3934094a', '/data/gannet/ripley/R/R-clang/library'
  > message("Package path: ", sQuote(system.file(package = "future")))
  Package path: '/data/gannet/ripley/R/packages/tests-clang/future.Rcheck/future'
  > 
  > types <- "PSOCK"
  > 
  > ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
  > if (isWin32) types <- NULL
  > 
  > if (supportsMulticore() && !on_solaris) types <- c(types, "FORK")
  > 
  > ## WORKAROUND: covr::package_coverage() -> merge_coverage() -> ... produces
  > ## "Error in readRDS(x) : error reading from connection" for type = "FORK".
  > ## Is this related to mcparallel() comments in help("package_coverage")?
  > ## /HB 2017-05-20
  > if (covr_testing) types <- setdiff(types, "FORK")
  > 
  > pid <- Sys.getpid()
  > message("Main PID (original): ", pid)
  Main PID (original): 696525
  > 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: 7c16cd70-6617-ef4a-ad64-032c3a96161c
  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 22723 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/cluster.R:gannet.stats.ox.ac.uk:ripley:696525' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/Rtmp0mSG68/future.parent=696525.aa0cdc577df6.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=22723 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 696573) 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:16:37.627] plan(): Setting new future strategy stack:
  [07:16:37.628] List of future strategies:
  [07:16:37.628] 1. sequential:
  [07:16:37.628]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:37.628]    - tweaked: FALSE
  [07:16:37.628]    - call: future::plan("sequential")
  [07:16:37.629] 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:16:37.654] plan(): Setting new future strategy stack:
  [07:16:37.655] List of future strategies:
  [07:16:37.655] 1. sequential:
  [07:16:37.655]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:37.655]    - tweaked: FALSE
  [07:16:37.655]    - call: plan(sequential)
  [07:16:37.674] 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:16:37.691] getGlobalsAndPackages() ...
  [07:16:37.691] Searching for globals...
  [07:16:37.698] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.699] Searching for globals ... DONE
  [07:16:37.699] Resolving globals: FALSE
  [07:16:37.701] The total size of the 2 globals is 224 bytes (224 bytes)
  [07:16:37.701] - globals: [2] 'x', 'i'
  [07:16:37.701] 
  [07:16:37.702] getGlobalsAndPackages() ... DONE
  [07:16:37.703] getGlobalsAndPackages() ...
  [07:16:37.703] Searching for globals...
  [07:16:37.705] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.705] Searching for globals ... DONE
  [07:16:37.706] Resolving globals: FALSE
  [07:16:37.707] The total size of the 2 globals is 8.10 KiB (8296 bytes)
  [07:16:37.707] - globals: [2] 'x', 'i'
  [07:16:37.708] 
  [07:16:37.708] getGlobalsAndPackages() ... DONE
  [07:16:37.709] getGlobalsAndPackages() ...
  [07:16:37.709] Searching for globals...
  [07:16:37.711] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.711] Searching for globals ... DONE
  [07:16:37.712] Resolving globals: FALSE
  [07:16:37.713] The total size of the 2 globals is 16.15 KiB (16536 bytes)
  [07:16:37.714] - globals: [2] 'x', 'i'
  [07:16:37.714] 
  [07:16:37.714] getGlobalsAndPackages() ... DONE
  [07:16:37.715] getGlobalsAndPackages() ...
  [07:16:37.716] Searching for globals...
  [07:16:37.718] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.718] Searching for globals ... DONE
  [07:16:37.718] Resolving globals: FALSE
  [07:16:37.720] The total size of the 2 globals is 24.20 KiB (24776 bytes)
  [07:16:37.721] - globals: [2] 'x', 'i'
  [07:16:37.721] 
  [07:16:37.721] getGlobalsAndPackages() ... DONE
  [07:16:37.722] getGlobalsAndPackages() ...
  [07:16:37.722] Searching for globals...
  [07:16:37.724] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.725] Searching for globals ... DONE
  [07:16:37.725] Resolving globals: FALSE
  [07:16:37.728] The total size of the 2 globals is 32.24 KiB (33016 bytes)
  [07:16:37.728] - globals: [2] 'x', 'i'
  [07:16:37.728] 
  [07:16:37.729] getGlobalsAndPackages() ... DONE
  [07:16:37.730] getGlobalsAndPackages() ...
  [07:16:37.730] Searching for globals...
  [07:16:37.732] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.732] Searching for globals ... DONE
  [07:16:37.732] Resolving globals: FALSE
  [07:16:37.736] The total size of the 2 globals is 40.29 KiB (41256 bytes)
  [07:16:37.736] - globals: [2] 'x', 'i'
  [07:16:37.736] 
  [07:16:37.737] getGlobalsAndPackages() ... DONE
  [07:16:37.737] getGlobalsAndPackages() ...
  [07:16:37.738] Searching for globals...
  [07:16:37.740] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.740] Searching for globals ... DONE
  [07:16:37.740] Resolving globals: FALSE
  [07:16:37.747] The total size of the 2 globals is 48.34 KiB (49496 bytes)
  [07:16:37.747] - globals: [2] 'x', 'i'
  [07:16:37.747] 
  [07:16:37.747] getGlobalsAndPackages() ... DONE
  [07:16:37.748] getGlobalsAndPackages() ...
  [07:16:37.749] Searching for globals...
  [07:16:37.751] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.751] Searching for globals ... DONE
  [07:16:37.751] Resolving globals: FALSE
  [07:16:37.755] The total size of the 2 globals is 56.38 KiB (57736 bytes)
  [07:16:37.756] - globals: [2] 'x', 'i'
  [07:16:37.756] 
  [07:16:37.756] getGlobalsAndPackages() ... DONE
  [07:16:37.757] getGlobalsAndPackages() ...
  [07:16:37.757] Searching for globals...
  [07:16:37.759] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.760] Searching for globals ... DONE
  [07:16:37.760] Resolving globals: FALSE
  [07:16:37.764] The total size of the 2 globals is 64.43 KiB (65976 bytes)
  [07:16:37.765] - globals: [2] 'x', 'i'
  [07:16:37.765] 
  [07:16:37.765] getGlobalsAndPackages() ... DONE
  [07:16:37.766] getGlobalsAndPackages() ...
  [07:16:37.767] Searching for globals...
  [07:16:37.768] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.769] Searching for globals ... DONE
  [07:16:37.769] Resolving globals: FALSE
  [07:16:37.774] The total size of the 2 globals is 72.48 KiB (74216 bytes)
  [07:16:37.774] - globals: [2] 'x', 'i'
  [07:16:37.775] 
  [07:16:37.775] getGlobalsAndPackages() ... DONE
  [07:16:37.776] getGlobalsAndPackages() ...
  [07:16:37.776] Searching for globals...
  [07:16:37.778] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.778] Searching for globals ... DONE
  [07:16:37.779] Resolving globals: FALSE
  [07:16:37.784] The total size of the 2 globals is 80.52 KiB (82456 bytes)
  [07:16:37.784] - globals: [2] 'x', 'i'
  [07:16:37.785] 
  [07:16:37.785] getGlobalsAndPackages() ... DONE
  [07:16:37.786] getGlobalsAndPackages() ...
  [07:16:37.786] Searching for globals...
  [07:16:37.790] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.790] Searching for globals ... DONE
  [07:16:37.790] Resolving globals: FALSE
  [07:16:37.796] The total size of the 2 globals is 88.57 KiB (90696 bytes)
  [07:16:37.797] - globals: [2] 'x', 'i'
  [07:16:37.797] 
  [07:16:37.797] getGlobalsAndPackages() ... DONE
  [07:16:37.798] getGlobalsAndPackages() ...
  [07:16:37.798] Searching for globals...
  [07:16:37.800] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.801] Searching for globals ... DONE
  [07:16:37.801] Resolving globals: FALSE
  [07:16:37.807] The total size of the 2 globals is 96.62 KiB (98936 bytes)
  [07:16:37.808] - globals: [2] 'x', 'i'
  [07:16:37.808] 
  [07:16:37.808] getGlobalsAndPackages() ... DONE
  [07:16:37.809] getGlobalsAndPackages() ...
  [07:16:37.809] Searching for globals...
  [07:16:37.811] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.812] Searching for globals ... DONE
  [07:16:37.812] Resolving globals: FALSE
  [07:16:37.819] The total size of the 2 globals is 104.66 KiB (107176 bytes)
  [07:16:37.819] - globals: [2] 'x', 'i'
  [07:16:37.819] 
  [07:16:37.820] getGlobalsAndPackages() ... DONE
  [07:16:37.821] getGlobalsAndPackages() ...
  [07:16:37.821] Searching for globals...
  [07:16:37.823] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.823] Searching for globals ... DONE
  [07:16:37.823] Resolving globals: FALSE
  [07:16:37.832] The total size of the 2 globals is 112.71 KiB (115416 bytes)
  [07:16:37.833] - globals: [2] 'x', 'i'
  [07:16:37.833] 
  [07:16:37.833] getGlobalsAndPackages() ... DONE
  [07:16:37.834] getGlobalsAndPackages() ...
  [07:16:37.834] Searching for globals...
  [07:16:37.836] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.837] Searching for globals ... DONE
  [07:16:37.837] Resolving globals: FALSE
  [07:16:37.845] The total size of the 2 globals is 120.76 KiB (123656 bytes)
  [07:16:37.845] - globals: [2] 'x', 'i'
  [07:16:37.845] 
  [07:16:37.846] getGlobalsAndPackages() ... DONE
  [07:16:37.846] getGlobalsAndPackages() ...
  [07:16:37.847] Searching for globals...
  [07:16:37.849] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.849] Searching for globals ... DONE
  [07:16:37.849] Resolving globals: FALSE
  [07:16:37.857] The total size of the 2 globals is 128.80 KiB (131896 bytes)
  [07:16:37.858] - globals: [2] 'x', 'i'
  [07:16:37.858] 
  [07:16:37.858] getGlobalsAndPackages() ... DONE
  [07:16:37.859] getGlobalsAndPackages() ...
  [07:16:37.859] Searching for globals...
  [07:16:37.861] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.862] Searching for globals ... DONE
  [07:16:37.862] Resolving globals: FALSE
  [07:16:37.871] The total size of the 2 globals is 136.85 KiB (140136 bytes)
  [07:16:37.871] - globals: [2] 'x', 'i'
  [07:16:37.873] 
  [07:16:37.873] getGlobalsAndPackages() ... DONE
  [07:16:37.874] getGlobalsAndPackages() ...
  [07:16:37.874] Searching for globals...
  [07:16:37.876] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.877] Searching for globals ... DONE
  [07:16:37.877] Resolving globals: FALSE
  [07:16:37.886] The total size of the 2 globals is 144.90 KiB (148376 bytes)
  [07:16:37.886] - globals: [2] 'x', 'i'
  [07:16:37.887] 
  [07:16:37.887] getGlobalsAndPackages() ... DONE
  [07:16:37.888] getGlobalsAndPackages() ...
  [07:16:37.888] Searching for globals...
  [07:16:37.890] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.890] Searching for globals ... DONE
  [07:16:37.891] Resolving globals: FALSE
  [07:16:37.900] The total size of the 2 globals is 152.95 KiB (156616 bytes)
  [07:16:37.900] - globals: [2] 'x', 'i'
  [07:16:37.901] 
  [07:16:37.901] getGlobalsAndPackages() ... DONE
  [07:16:37.902] getGlobalsAndPackages() ...
  [07:16:37.902] Searching for globals...
  [07:16:37.904] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.904] Searching for globals ... DONE
  [07:16:37.905] Resolving globals: FALSE
  [07:16:37.916] The total size of the 2 globals is 160.99 KiB (164856 bytes)
  [07:16:37.917] - globals: [2] 'x', 'i'
  [07:16:37.917] 
  [07:16:37.917] getGlobalsAndPackages() ... DONE
  [07:16:37.918] getGlobalsAndPackages() ...
  [07:16:37.918] Searching for globals...
  [07:16:37.920] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.921] Searching for globals ... DONE
  [07:16:37.921] Resolving globals: FALSE
  [07:16:37.931] The total size of the 2 globals is 169.04 KiB (173096 bytes)
  [07:16:37.932] - globals: [2] 'x', 'i'
  [07:16:37.932] 
  [07:16:37.932] getGlobalsAndPackages() ... DONE
  [07:16:37.933] getGlobalsAndPackages() ...
  [07:16:37.933] Searching for globals...
  [07:16:37.935] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.936] Searching for globals ... DONE
  [07:16:37.936] Resolving globals: FALSE
  [07:16:37.947] The total size of the 2 globals is 177.09 KiB (181336 bytes)
  [07:16:37.947] - globals: [2] 'x', 'i'
  [07:16:37.948] 
  [07:16:37.948] getGlobalsAndPackages() ... DONE
  [07:16:37.949] getGlobalsAndPackages() ...
  [07:16:37.949] Searching for globals...
  [07:16:37.953] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.953] Searching for globals ... DONE
  [07:16:37.953] Resolving globals: FALSE
  [07:16:37.965] The total size of the 2 globals is 185.13 KiB (189576 bytes)
  [07:16:37.965] - globals: [2] 'x', 'i'
  [07:16:37.965] 
  [07:16:37.965] getGlobalsAndPackages() ... DONE
  [07:16:37.966] getGlobalsAndPackages() ...
  [07:16:37.967] Searching for globals...
  [07:16:37.969] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.969] Searching for globals ... DONE
  [07:16:37.969] Resolving globals: FALSE
  [07:16:37.981] The total size of the 2 globals is 193.18 KiB (197816 bytes)
  [07:16:37.981] - globals: [2] 'x', 'i'
  [07:16:37.982] 
  [07:16:37.982] getGlobalsAndPackages() ... DONE
  [07:16:37.983] getGlobalsAndPackages() ...
  [07:16:37.983] Searching for globals...
  [07:16:37.985] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:37.985] Searching for globals ... DONE
  [07:16:37.986] Resolving globals: FALSE
  [07:16:38.000] The total size of the 2 globals is 201.23 KiB (206056 bytes)
  [07:16:38.000] - globals: [2] 'x', 'i'
  [07:16:38.000] 
  [07:16:38.001] getGlobalsAndPackages() ... DONE
  [07:16:38.002] getGlobalsAndPackages() ...
  [07:16:38.002] Searching for globals...
  [07:16:38.004] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.004] Searching for globals ... DONE
  [07:16:38.005] Resolving globals: FALSE
  [07:16:38.017] The total size of the 2 globals is 209.27 KiB (214296 bytes)
  [07:16:38.018] - globals: [2] 'x', 'i'
  [07:16:38.018] 
  [07:16:38.018] getGlobalsAndPackages() ... DONE
  [07:16:38.019] getGlobalsAndPackages() ...
  [07:16:38.019] Searching for globals...
  [07:16:38.021] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.022] Searching for globals ... DONE
  [07:16:38.022] Resolving globals: FALSE
  [07:16:38.037] The total size of the 2 globals is 217.32 KiB (222536 bytes)
  [07:16:38.037] - globals: [2] 'x', 'i'
  [07:16:38.037] 
  [07:16:38.038] getGlobalsAndPackages() ... DONE
  [07:16:38.039] getGlobalsAndPackages() ...
  [07:16:38.039] Searching for globals...
  [07:16:38.041] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.041] Searching for globals ... DONE
  [07:16:38.042] Resolving globals: FALSE
  [07:16:38.055] The total size of the 2 globals is 225.37 KiB (230776 bytes)
  [07:16:38.056] - globals: [2] 'x', 'i'
  [07:16:38.056] 
  [07:16:38.056] getGlobalsAndPackages() ... DONE
  [07:16:38.057] getGlobalsAndPackages() ...
  [07:16:38.057] Searching for globals...
  [07:16:38.059] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.060] Searching for globals ... DONE
  [07:16:38.060] Resolving globals: FALSE
  [07:16:38.076] The total size of the 2 globals is 233.41 KiB (239016 bytes)
  [07:16:38.076] - globals: [2] 'x', 'i'
  [07:16:38.077] 
  [07:16:38.077] getGlobalsAndPackages() ... DONE
  [07:16:38.078] getGlobalsAndPackages() ...
  [07:16:38.078] Searching for globals...
  [07:16:38.080] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.080] Searching for globals ... DONE
  [07:16:38.081] Resolving globals: FALSE
  [07:16:38.095] The total size of the 2 globals is 241.46 KiB (247256 bytes)
  [07:16:38.096] - globals: [2] 'x', 'i'
  [07:16:38.096] 
  [07:16:38.096] getGlobalsAndPackages() ... DONE
  [07:16:38.097] getGlobalsAndPackages() ...
  [07:16:38.097] Searching for globals...
  [07:16:38.099] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.100] Searching for globals ... DONE
  [07:16:38.100] Resolving globals: FALSE
  [07:16:38.117] The total size of the 2 globals is 249.51 KiB (255496 bytes)
  [07:16:38.117] - globals: [2] 'x', 'i'
  [07:16:38.117] 
  [07:16:38.118] getGlobalsAndPackages() ... DONE
  [07:16:38.119] getGlobalsAndPackages() ...
  [07:16:38.119] Searching for globals...
  [07:16:38.121] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.121] Searching for globals ... DONE
  [07:16:38.122] Resolving globals: FALSE
  [07:16:38.139] The total size of the 2 globals is 257.55 KiB (263736 bytes)
  [07:16:38.139] - globals: [2] 'x', 'i'
  [07:16:38.139] 
  [07:16:38.140] getGlobalsAndPackages() ... DONE
  [07:16:38.141] getGlobalsAndPackages() ...
  [07:16:38.141] Searching for globals...
  [07:16:38.143] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.143] Searching for globals ... DONE
  [07:16:38.144] Resolving globals: FALSE
  [07:16:38.160] The total size of the 2 globals is 265.60 KiB (271976 bytes)
  [07:16:38.160] - globals: [2] 'x', 'i'
  [07:16:38.160] 
  [07:16:38.161] getGlobalsAndPackages() ... DONE
  [07:16:38.162] getGlobalsAndPackages() ...
  [07:16:38.162] Searching for globals...
  [07:16:38.164] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.164] Searching for globals ... DONE
  [07:16:38.165] Resolving globals: FALSE
  [07:16:38.183] The total size of the 2 globals is 273.65 KiB (280216 bytes)
  [07:16:38.183] - globals: [2] 'x', 'i'
  [07:16:38.183] 
  [07:16:38.184] getGlobalsAndPackages() ... DONE
  [07:16:38.185] getGlobalsAndPackages() ...
  [07:16:38.185] Searching for globals...
  [07:16:38.187] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.187] Searching for globals ... DONE
  [07:16:38.188] Resolving globals: FALSE
  [07:16:38.205] The total size of the 2 globals is 281.70 KiB (288456 bytes)
  [07:16:38.205] - globals: [2] 'x', 'i'
  [07:16:38.205] 
  [07:16:38.206] getGlobalsAndPackages() ... DONE
  [07:16:38.207] getGlobalsAndPackages() ...
  [07:16:38.207] Searching for globals...
  [07:16:38.210] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.211] Searching for globals ... DONE
  [07:16:38.211] Resolving globals: FALSE
  [07:16:38.229] The total size of the 2 globals is 289.74 KiB (296696 bytes)
  [07:16:38.229] - globals: [2] 'x', 'i'
  [07:16:38.229] 
  [07:16:38.230] getGlobalsAndPackages() ... DONE
  [07:16:38.230] getGlobalsAndPackages() ...
  [07:16:38.231] Searching for globals...
  [07:16:38.233] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.233] Searching for globals ... DONE
  [07:16:38.233] Resolving globals: FALSE
  [07:16:38.253] The total size of the 2 globals is 297.79 KiB (304936 bytes)
  [07:16:38.253] - globals: [2] 'x', 'i'
  [07:16:38.254] 
  [07:16:38.254] getGlobalsAndPackages() ... DONE
  [07:16:38.255] getGlobalsAndPackages() ...
  [07:16:38.255] Searching for globals...
  [07:16:38.257] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.258] Searching for globals ... DONE
  [07:16:38.258] Resolving globals: FALSE
  [07:16:38.276] The total size of the 2 globals is 305.84 KiB (313176 bytes)
  [07:16:38.277] - globals: [2] 'x', 'i'
  [07:16:38.277] 
  [07:16:38.277] getGlobalsAndPackages() ... DONE
  [07:16:38.278] getGlobalsAndPackages() ...
  [07:16:38.279] Searching for globals...
  [07:16:38.282] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.283] Searching for globals ... DONE
  [07:16:38.283] Resolving globals: FALSE
  [07:16:38.302] The total size of the 2 globals is 313.88 KiB (321416 bytes)
  [07:16:38.302] - globals: [2] 'x', 'i'
  [07:16:38.303] 
  [07:16:38.303] getGlobalsAndPackages() ... DONE
  [07:16:38.304] getGlobalsAndPackages() ...
  [07:16:38.304] Searching for globals...
  [07:16:38.306] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.306] Searching for globals ... DONE
  [07:16:38.307] Resolving globals: FALSE
  [07:16:38.328] The total size of the 2 globals is 321.93 KiB (329656 bytes)
  [07:16:38.328] - globals: [2] 'x', 'i'
  [07:16:38.329] 
  [07:16:38.329] getGlobalsAndPackages() ... DONE
  [07:16:38.330] getGlobalsAndPackages() ...
  [07:16:38.330] Searching for globals...
  [07:16:38.332] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.332] Searching for globals ... DONE
  [07:16:38.333] Resolving globals: FALSE
  [07:16:38.354] The total size of the 2 globals is 329.98 KiB (337896 bytes)
  [07:16:38.355] - globals: [2] 'x', 'i'
  [07:16:38.355] 
  [07:16:38.355] getGlobalsAndPackages() ... DONE
  [07:16:38.356] getGlobalsAndPackages() ...
  [07:16:38.357] Searching for globals...
  [07:16:38.359] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.359] Searching for globals ... DONE
  [07:16:38.359] Resolving globals: FALSE
  [07:16:38.380] The total size of the 2 globals is 338.02 KiB (346136 bytes)
  [07:16:38.380] - globals: [2] 'x', 'i'
  [07:16:38.381] 
  [07:16:38.381] getGlobalsAndPackages() ... DONE
  [07:16:38.382] getGlobalsAndPackages() ...
  [07:16:38.382] Searching for globals...
  [07:16:38.386] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.386] Searching for globals ... DONE
  [07:16:38.386] Resolving globals: FALSE
  [07:16:38.407] The total size of the 2 globals is 346.07 KiB (354376 bytes)
  [07:16:38.408] - globals: [2] 'x', 'i'
  [07:16:38.408] 
  [07:16:38.408] getGlobalsAndPackages() ... DONE
  [07:16:38.409] getGlobalsAndPackages() ...
  [07:16:38.410] Searching for globals...
  [07:16:38.412] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.412] Searching for globals ... DONE
  [07:16:38.412] Resolving globals: FALSE
  [07:16:38.464] The total size of the 2 globals is 354.12 KiB (362616 bytes)
  [07:16:38.465] - globals: [2] 'x', 'i'
  [07:16:38.465] 
  [07:16:38.465] getGlobalsAndPackages() ... DONE
  [07:16:38.466] getGlobalsAndPackages() ...
  [07:16:38.467] Searching for globals...
  [07:16:38.469] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.469] Searching for globals ... DONE
  [07:16:38.469] Resolving globals: FALSE
  [07:16:38.494] The total size of the 2 globals is 362.16 KiB (370856 bytes)
  [07:16:38.494] - globals: [2] 'x', 'i'
  [07:16:38.494] 
  [07:16:38.495] getGlobalsAndPackages() ... DONE
  [07:16:38.495] getGlobalsAndPackages() ...
  [07:16:38.496] Searching for globals...
  [07:16:38.498] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.498] Searching for globals ... DONE
  [07:16:38.498] Resolving globals: FALSE
  [07:16:38.523] The total size of the 2 globals is 370.21 KiB (379096 bytes)
  [07:16:38.523] - globals: [2] 'x', 'i'
  [07:16:38.523] 
  [07:16:38.524] getGlobalsAndPackages() ... DONE
  [07:16:38.525] getGlobalsAndPackages() ...
  [07:16:38.525] Searching for globals...
  [07:16:38.527] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.527] Searching for globals ... DONE
  [07:16:38.528] Resolving globals: FALSE
  [07:16:38.551] The total size of the 2 globals is 378.26 KiB (387336 bytes)
  [07:16:38.551] - globals: [2] 'x', 'i'
  [07:16:38.552] 
  [07:16:38.552] getGlobalsAndPackages() ... DONE
  [07:16:38.554] getGlobalsAndPackages() ...
  [07:16:38.555] Searching for globals...
  [07:16:38.557] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.557] Searching for globals ... DONE
  [07:16:38.557] Resolving globals: FALSE
  [07:16:38.581] The total size of the 2 globals is 386.30 KiB (395576 bytes)
  [07:16:38.581] - globals: [2] 'x', 'i'
  [07:16:38.582] 
  [07:16:38.582] getGlobalsAndPackages() ... DONE
  [07:16:38.583] getGlobalsAndPackages() ...
  [07:16:38.583] Searching for globals...
  [07:16:38.585] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.586] Searching for globals ... DONE
  [07:16:38.586] Resolving globals: FALSE
  [07:16:38.612] The total size of the 2 globals is 394.35 KiB (403816 bytes)
  [07:16:38.612] - globals: [2] 'x', 'i'
  [07:16:38.612] 
  [07:16:38.613] getGlobalsAndPackages() ... DONE
  [07:16:38.614] getGlobalsAndPackages() ...
  [07:16:38.614] Searching for globals...
  [07:16:38.616] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.616] Searching for globals ... DONE
  [07:16:38.616] Resolving globals: FALSE
  [07:16:38.643] The total size of the 2 globals is 402.40 KiB (412056 bytes)
  [07:16:38.643] - globals: [2] 'x', 'i'
  [07:16:38.643] 
  [07:16:38.644] getGlobalsAndPackages() ... DONE
  [07:16:38.645] getGlobalsAndPackages() ...
  [07:16:38.645] Searching for globals...
  [07:16:38.647] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.647] Searching for globals ... DONE
  [07:16:38.648] Resolving globals: FALSE
  [07:16:38.674] The total size of the 2 globals is 410.45 KiB (420296 bytes)
  [07:16:38.675] - globals: [2] 'x', 'i'
  [07:16:38.675] 
  [07:16:38.675] getGlobalsAndPackages() ... DONE
  [07:16:38.676] getGlobalsAndPackages() ...
  [07:16:38.677] Searching for globals...
  [07:16:38.679] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.679] Searching for globals ... DONE
  [07:16:38.679] Resolving globals: FALSE
  [07:16:38.707] The total size of the 2 globals is 418.49 KiB (428536 bytes)
  [07:16:38.707] - globals: [2] 'x', 'i'
  [07:16:38.707] 
  [07:16:38.708] getGlobalsAndPackages() ... DONE
  [07:16:38.709] getGlobalsAndPackages() ...
  [07:16:38.709] Searching for globals...
  [07:16:38.711] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.711] Searching for globals ... DONE
  [07:16:38.711] Resolving globals: FALSE
  [07:16:38.739] The total size of the 2 globals is 426.54 KiB (436776 bytes)
  [07:16:38.740] - globals: [2] 'x', 'i'
  [07:16:38.740] 
  [07:16:38.740] getGlobalsAndPackages() ... DONE
  [07:16:38.741] getGlobalsAndPackages() ...
  [07:16:38.741] Searching for globals...
  [07:16:38.744] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.744] Searching for globals ... DONE
  [07:16:38.744] Resolving globals: FALSE
  [07:16:38.772] The total size of the 2 globals is 434.59 KiB (445016 bytes)
  [07:16:38.773] - globals: [2] 'x', 'i'
  [07:16:38.773] 
  [07:16:38.773] getGlobalsAndPackages() ... DONE
  [07:16:38.774] getGlobalsAndPackages() ...
  [07:16:38.775] Searching for globals...
  [07:16:38.777] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.777] Searching for globals ... DONE
  [07:16:38.777] Resolving globals: FALSE
  [07:16:38.806] The total size of the 2 globals is 442.63 KiB (453256 bytes)
  [07:16:38.806] - globals: [2] 'x', 'i'
  [07:16:38.807] 
  [07:16:38.807] getGlobalsAndPackages() ... DONE
  [07:16:38.808] getGlobalsAndPackages() ...
  [07:16:38.808] Searching for globals...
  [07:16:38.810] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.811] Searching for globals ... DONE
  [07:16:38.811] Resolving globals: FALSE
  [07:16:38.840] The total size of the 2 globals is 450.68 KiB (461496 bytes)
  [07:16:38.841] - globals: [2] 'x', 'i'
  [07:16:38.841] 
  [07:16:38.841] getGlobalsAndPackages() ... DONE
  [07:16:38.842] getGlobalsAndPackages() ...
  [07:16:38.843] Searching for globals...
  [07:16:38.845] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.845] Searching for globals ... DONE
  [07:16:38.845] Resolving globals: FALSE
  [07:16:38.875] The total size of the 2 globals is 458.73 KiB (469736 bytes)
  [07:16:38.875] - globals: [2] 'x', 'i'
  [07:16:38.876] 
  [07:16:38.876] getGlobalsAndPackages() ... DONE
  [07:16:38.877] getGlobalsAndPackages() ...
  [07:16:38.877] Searching for globals...
  [07:16:38.879] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.880] Searching for globals ... DONE
  [07:16:38.880] Resolving globals: FALSE
  [07:16:38.910] The total size of the 2 globals is 466.77 KiB (477976 bytes)
  [07:16:38.911] - globals: [2] 'x', 'i'
  [07:16:38.911] 
  [07:16:38.911] getGlobalsAndPackages() ... DONE
  [07:16:38.912] getGlobalsAndPackages() ...
  [07:16:38.913] Searching for globals...
  [07:16:38.915] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.915] Searching for globals ... DONE
  [07:16:38.915] Resolving globals: FALSE
  [07:16:38.946] The total size of the 2 globals is 474.82 KiB (486216 bytes)
  [07:16:38.947] - globals: [2] 'x', 'i'
  [07:16:38.947] 
  [07:16:38.947] getGlobalsAndPackages() ... DONE
  [07:16:38.948] getGlobalsAndPackages() ...
  [07:16:38.948] Searching for globals...
  [07:16:38.950] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.951] Searching for globals ... DONE
  [07:16:38.951] Resolving globals: FALSE
  [07:16:38.982] The total size of the 2 globals is 482.87 KiB (494456 bytes)
  [07:16:38.983] - globals: [2] 'x', 'i'
  [07:16:38.983] 
  [07:16:38.983] getGlobalsAndPackages() ... DONE
  [07:16:38.984] getGlobalsAndPackages() ...
  [07:16:38.985] Searching for globals...
  [07:16:38.987] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:38.987] Searching for globals ... DONE
  [07:16:38.987] Resolving globals: FALSE
  [07:16:39.019] The total size of the 2 globals is 490.91 KiB (502696 bytes)
  [07:16:39.020] - globals: [2] 'x', 'i'
  [07:16:39.020] 
  [07:16:39.020] getGlobalsAndPackages() ... DONE
  [07:16:39.021] getGlobalsAndPackages() ...
  [07:16:39.022] Searching for globals...
  [07:16:39.024] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.024] Searching for globals ... DONE
  [07:16:39.024] Resolving globals: FALSE
  [07:16:39.058] The total size of the 2 globals is 498.96 KiB (510936 bytes)
  [07:16:39.059] - globals: [2] 'x', 'i'
  [07:16:39.059] 
  [07:16:39.059] getGlobalsAndPackages() ... DONE
  [07:16:39.060] getGlobalsAndPackages() ...
  [07:16:39.061] Searching for globals...
  [07:16:39.063] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.063] Searching for globals ... DONE
  [07:16:39.063] Resolving globals: FALSE
  [07:16:39.096] The total size of the 2 globals is 507.01 KiB (519176 bytes)
  [07:16:39.097] - globals: [2] 'x', 'i'
  [07:16:39.097] 
  [07:16:39.097] getGlobalsAndPackages() ... DONE
  [07:16:39.098] getGlobalsAndPackages() ...
  [07:16:39.099] Searching for globals...
  [07:16:39.101] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.101] Searching for globals ... DONE
  [07:16:39.101] Resolving globals: FALSE
  [07:16:39.135] The total size of the 2 globals is 515.05 KiB (527416 bytes)
  [07:16:39.135] - globals: [2] 'x', 'i'
  [07:16:39.136] 
  [07:16:39.136] getGlobalsAndPackages() ... DONE
  [07:16:39.137] getGlobalsAndPackages() ...
  [07:16:39.137] Searching for globals...
  [07:16:39.139] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.140] Searching for globals ... DONE
  [07:16:39.140] Resolving globals: FALSE
  [07:16:39.175] The total size of the 2 globals is 523.10 KiB (535656 bytes)
  [07:16:39.176] - globals: [2] 'x', 'i'
  [07:16:39.176] 
  [07:16:39.176] getGlobalsAndPackages() ... DONE
  [07:16:39.177] getGlobalsAndPackages() ...
  [07:16:39.178] Searching for globals...
  [07:16:39.180] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.180] Searching for globals ... DONE
  [07:16:39.180] Resolving globals: FALSE
  [07:16:39.216] The total size of the 2 globals is 531.15 KiB (543896 bytes)
  [07:16:39.217] - globals: [2] 'x', 'i'
  [07:16:39.217] 
  [07:16:39.218] getGlobalsAndPackages() ... DONE
  [07:16:39.219] getGlobalsAndPackages() ...
  [07:16:39.219] Searching for globals...
  [07:16:39.221] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.221] Searching for globals ... DONE
  [07:16:39.222] Resolving globals: FALSE
  [07:16:39.259] The total size of the 2 globals is 539.20 KiB (552136 bytes)
  [07:16:39.259] - globals: [2] 'x', 'i'
  [07:16:39.259] 
  [07:16:39.260] getGlobalsAndPackages() ... DONE
  [07:16:39.261] getGlobalsAndPackages() ...
  [07:16:39.261] Searching for globals...
  [07:16:39.263] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.263] Searching for globals ... DONE
  [07:16:39.264] Resolving globals: FALSE
  [07:16:39.299] The total size of the 2 globals is 547.24 KiB (560376 bytes)
  [07:16:39.300] - globals: [2] 'x', 'i'
  [07:16:39.300] 
  [07:16:39.300] getGlobalsAndPackages() ... DONE
  [07:16:39.301] getGlobalsAndPackages() ...
  [07:16:39.302] Searching for globals...
  [07:16:39.304] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.304] Searching for globals ... DONE
  [07:16:39.304] Resolving globals: FALSE
  [07:16:39.341] The total size of the 2 globals is 555.29 KiB (568616 bytes)
  [07:16:39.341] - globals: [2] 'x', 'i'
  [07:16:39.341] 
  [07:16:39.342] getGlobalsAndPackages() ... DONE
  [07:16:39.343] getGlobalsAndPackages() ...
  [07:16:39.343] Searching for globals...
  [07:16:39.346] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.346] Searching for globals ... DONE
  [07:16:39.347] Resolving globals: FALSE
  [07:16:39.384] The total size of the 2 globals is 563.34 KiB (576856 bytes)
  [07:16:39.384] - globals: [2] 'x', 'i'
  [07:16:39.384] 
  [07:16:39.385] getGlobalsAndPackages() ... DONE
  [07:16:39.386] getGlobalsAndPackages() ...
  [07:16:39.386] Searching for globals...
  [07:16:39.388] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.388] Searching for globals ... DONE
  [07:16:39.389] Resolving globals: FALSE
  [07:16:39.428] The total size of the 2 globals is 571.38 KiB (585096 bytes)
  [07:16:39.428] - globals: [2] 'x', 'i'
  [07:16:39.428] 
  [07:16:39.429] getGlobalsAndPackages() ... DONE
  [07:16:39.430] getGlobalsAndPackages() ...
  [07:16:39.430] Searching for globals...
  [07:16:39.432] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.432] Searching for globals ... DONE
  [07:16:39.433] Resolving globals: FALSE
  [07:16:39.471] The total size of the 2 globals is 579.43 KiB (593336 bytes)
  [07:16:39.471] - globals: [2] 'x', 'i'
  [07:16:39.471] 
  [07:16:39.472] getGlobalsAndPackages() ... DONE
  [07:16:39.473] getGlobalsAndPackages() ...
  [07:16:39.473] Searching for globals...
  [07:16:39.475] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.475] Searching for globals ... DONE
  [07:16:39.476] Resolving globals: FALSE
  [07:16:39.514] The total size of the 2 globals is 587.48 KiB (601576 bytes)
  [07:16:39.514] - globals: [2] 'x', 'i'
  [07:16:39.515] 
  [07:16:39.515] getGlobalsAndPackages() ... DONE
  [07:16:39.516] getGlobalsAndPackages() ...
  [07:16:39.516] Searching for globals...
  [07:16:39.518] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.519] Searching for globals ... DONE
  [07:16:39.519] Resolving globals: FALSE
  [07:16:39.559] The total size of the 2 globals is 595.52 KiB (609816 bytes)
  [07:16:39.560] - globals: [2] 'x', 'i'
  [07:16:39.560] 
  [07:16:39.561] getGlobalsAndPackages() ... DONE
  [07:16:39.562] getGlobalsAndPackages() ...
  [07:16:39.562] Searching for globals...
  [07:16:39.564] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.564] Searching for globals ... DONE
  [07:16:39.565] Resolving globals: FALSE
  [07:16:39.604] The total size of the 2 globals is 603.57 KiB (618056 bytes)
  [07:16:39.604] - globals: [2] 'x', 'i'
  [07:16:39.605] 
  [07:16:39.605] getGlobalsAndPackages() ... DONE
  [07:16:39.606] getGlobalsAndPackages() ...
  [07:16:39.606] Searching for globals...
  [07:16:39.608] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.609] Searching for globals ... DONE
  [07:16:39.609] Resolving globals: FALSE
  [07:16:39.651] The total size of the 2 globals is 611.62 KiB (626296 bytes)
  [07:16:39.651] - globals: [2] 'x', 'i'
  [07:16:39.651] 
  [07:16:39.652] getGlobalsAndPackages() ... DONE
  [07:16:39.653] getGlobalsAndPackages() ...
  [07:16:39.653] Searching for globals...
  [07:16:39.655] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.655] Searching for globals ... DONE
  [07:16:39.656] Resolving globals: FALSE
  [07:16:39.696] The total size of the 2 globals is 619.66 KiB (634536 bytes)
  [07:16:39.697] - globals: [2] 'x', 'i'
  [07:16:39.697] 
  [07:16:39.697] getGlobalsAndPackages() ... DONE
  [07:16:39.698] getGlobalsAndPackages() ...
  [07:16:39.698] Searching for globals...
  [07:16:39.700] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.701] Searching for globals ... DONE
  [07:16:39.701] Resolving globals: FALSE
  [07:16:39.744] The total size of the 2 globals is 627.71 KiB (642776 bytes)
  [07:16:39.744] - globals: [2] 'x', 'i'
  [07:16:39.744] 
  [07:16:39.745] getGlobalsAndPackages() ... DONE
  [07:16:39.746] getGlobalsAndPackages() ...
  [07:16:39.746] Searching for globals...
  [07:16:39.748] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.748] Searching for globals ... DONE
  [07:16:39.749] Resolving globals: FALSE
  [07:16:39.790] The total size of the 2 globals is 635.76 KiB (651016 bytes)
  [07:16:39.791] - globals: [2] 'x', 'i'
  [07:16:39.791] 
  [07:16:39.791] getGlobalsAndPackages() ... DONE
  [07:16:39.792] getGlobalsAndPackages() ...
  [07:16:39.793] Searching for globals...
  [07:16:39.795] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.795] Searching for globals ... DONE
  [07:16:39.795] Resolving globals: FALSE
  [07:16:39.840] The total size of the 2 globals is 643.80 KiB (659256 bytes)
  [07:16:39.840] - globals: [2] 'x', 'i'
  [07:16:39.840] 
  [07:16:39.841] getGlobalsAndPackages() ... DONE
  [07:16:39.842] getGlobalsAndPackages() ...
  [07:16:39.842] Searching for globals...
  [07:16:39.844] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.844] Searching for globals ... DONE
  [07:16:39.845] Resolving globals: FALSE
  [07:16:39.888] The total size of the 2 globals is 651.85 KiB (667496 bytes)
  [07:16:39.888] - globals: [2] 'x', 'i'
  [07:16:39.888] 
  [07:16:39.889] getGlobalsAndPackages() ... DONE
  [07:16:39.890] getGlobalsAndPackages() ...
  [07:16:39.890] Searching for globals...
  [07:16:39.892] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.892] Searching for globals ... DONE
  [07:16:39.893] Resolving globals: FALSE
  [07:16:39.938] The total size of the 2 globals is 659.90 KiB (675736 bytes)
  [07:16:39.938] - globals: [2] 'x', 'i'
  [07:16:39.939] 
  [07:16:39.939] getGlobalsAndPackages() ... DONE
  [07:16:39.940] getGlobalsAndPackages() ...
  [07:16:39.940] Searching for globals...
  [07:16:39.942] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.943] Searching for globals ... DONE
  [07:16:39.943] Resolving globals: FALSE
  [07:16:39.987] The total size of the 2 globals is 667.95 KiB (683976 bytes)
  [07:16:39.987] - globals: [2] 'x', 'i'
  [07:16:39.988] 
  [07:16:39.988] getGlobalsAndPackages() ... DONE
  [07:16:39.989] getGlobalsAndPackages() ...
  [07:16:39.989] Searching for globals...
  [07:16:39.993] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:39.993] Searching for globals ... DONE
  [07:16:39.993] Resolving globals: FALSE
  [07:16:40.038] The total size of the 2 globals is 675.99 KiB (692216 bytes)
  [07:16:40.039] - globals: [2] 'x', 'i'
  [07:16:40.039] 
  [07:16:40.039] getGlobalsAndPackages() ... DONE
  [07:16:40.040] getGlobalsAndPackages() ...
  [07:16:40.040] Searching for globals...
  [07:16:40.043] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.043] Searching for globals ... DONE
  [07:16:40.043] Resolving globals: FALSE
  [07:16:40.090] The total size of the 2 globals is 684.04 KiB (700456 bytes)
  [07:16:40.090] - globals: [2] 'x', 'i'
  [07:16:40.091] 
  [07:16:40.091] getGlobalsAndPackages() ... DONE
  [07:16:40.092] getGlobalsAndPackages() ...
  [07:16:40.092] Searching for globals...
  [07:16:40.094] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.095] Searching for globals ... DONE
  [07:16:40.095] Resolving globals: FALSE
  [07:16:40.141] The total size of the 2 globals is 692.09 KiB (708696 bytes)
  [07:16:40.141] - globals: [2] 'x', 'i'
  [07:16:40.141] 
  [07:16:40.142] getGlobalsAndPackages() ... DONE
  [07:16:40.143] getGlobalsAndPackages() ...
  [07:16:40.143] Searching for globals...
  [07:16:40.145] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.145] Searching for globals ... DONE
  [07:16:40.146] Resolving globals: FALSE
  [07:16:40.194] The total size of the 2 globals is 700.13 KiB (716936 bytes)
  [07:16:40.194] - globals: [2] 'x', 'i'
  [07:16:40.194] 
  [07:16:40.195] getGlobalsAndPackages() ... DONE
  [07:16:40.196] getGlobalsAndPackages() ...
  [07:16:40.196] Searching for globals...
  [07:16:40.198] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.198] Searching for globals ... DONE
  [07:16:40.199] Resolving globals: FALSE
  [07:16:40.247] The total size of the 2 globals is 708.18 KiB (725176 bytes)
  [07:16:40.248] - globals: [2] 'x', 'i'
  [07:16:40.248] 
  [07:16:40.248] getGlobalsAndPackages() ... DONE
  [07:16:40.249] getGlobalsAndPackages() ...
  [07:16:40.249] Searching for globals...
  [07:16:40.251] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.252] Searching for globals ... DONE
  [07:16:40.252] Resolving globals: FALSE
  [07:16:40.301] The total size of the 2 globals is 716.23 KiB (733416 bytes)
  [07:16:40.301] - globals: [2] 'x', 'i'
  [07:16:40.302] 
  [07:16:40.302] getGlobalsAndPackages() ... DONE
  [07:16:40.303] getGlobalsAndPackages() ...
  [07:16:40.303] Searching for globals...
  [07:16:40.306] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.306] Searching for globals ... DONE
  [07:16:40.306] Resolving globals: FALSE
  [07:16:40.355] The total size of the 2 globals is 724.27 KiB (741656 bytes)
  [07:16:40.355] - globals: [2] 'x', 'i'
  [07:16:40.356] 
  [07:16:40.356] getGlobalsAndPackages() ... DONE
  [07:16:40.357] getGlobalsAndPackages() ...
  [07:16:40.357] Searching for globals...
  [07:16:40.359] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.360] Searching for globals ... DONE
  [07:16:40.360] Resolving globals: FALSE
  [07:16:40.410] The total size of the 2 globals is 732.32 KiB (749896 bytes)
  [07:16:40.411] - globals: [2] 'x', 'i'
  [07:16:40.411] 
  [07:16:40.412] getGlobalsAndPackages() ... DONE
  [07:16:40.413] getGlobalsAndPackages() ...
  [07:16:40.413] Searching for globals...
  [07:16:40.415] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.415] Searching for globals ... DONE
  [07:16:40.416] Resolving globals: FALSE
  [07:16:40.467] The total size of the 2 globals is 740.37 KiB (758136 bytes)
  [07:16:40.467] - globals: [2] 'x', 'i'
  [07:16:40.467] 
  [07:16:40.468] getGlobalsAndPackages() ... DONE
  [07:16:40.469] getGlobalsAndPackages() ...
  [07:16:40.469] Searching for globals...
  [07:16:40.471] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.471] Searching for globals ... DONE
  [07:16:40.472] Resolving globals: FALSE
  [07:16:40.524] The total size of the 2 globals is 748.41 KiB (766376 bytes)
  [07:16:40.525] - globals: [2] 'x', 'i'
  [07:16:40.525] 
  [07:16:40.525] getGlobalsAndPackages() ... DONE
  [07:16:40.526] getGlobalsAndPackages() ...
  [07:16:40.527] Searching for globals...
  [07:16:40.529] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.529] Searching for globals ... DONE
  [07:16:40.529] Resolving globals: FALSE
  [07:16:40.581] The total size of the 2 globals is 756.46 KiB (774616 bytes)
  [07:16:40.582] - globals: [2] 'x', 'i'
  [07:16:40.582] 
  [07:16:40.582] getGlobalsAndPackages() ... DONE
  [07:16:40.583] getGlobalsAndPackages() ...
  [07:16:40.584] Searching for globals...
  [07:16:40.586] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.586] Searching for globals ... DONE
  [07:16:40.586] Resolving globals: FALSE
  [07:16:40.639] The total size of the 2 globals is 764.51 KiB (782856 bytes)
  [07:16:40.639] - globals: [2] 'x', 'i'
  [07:16:40.639] 
  [07:16:40.640] getGlobalsAndPackages() ... DONE
  [07:16:40.641] getGlobalsAndPackages() ...
  [07:16:40.641] Searching for globals...
  [07:16:40.643] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.644] Searching for globals ... DONE
  [07:16:40.644] Resolving globals: FALSE
  [07:16:40.695] The total size of the 2 globals is 772.55 KiB (791096 bytes)
  [07:16:40.696] - globals: [2] 'x', 'i'
  [07:16:40.696] 
  [07:16:40.696] getGlobalsAndPackages() ... DONE
  [07:16:40.697] getGlobalsAndPackages() ...
  [07:16:40.697] Searching for globals...
  [07:16:40.701] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
  [07:16:40.701] Searching for globals ... DONE
  [07:16:40.702] Resolving globals: FALSE
  [07:16:40.754] The total size of the 2 globals is 780.60 KiB (799336 bytes)
  [07:16:40.754] - globals: [2] 'x', 'i'
  [07:16:40.755] 
  [07:16:40.755] 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:16:40.758] Packages needed by the future expression (n = 0): <none>
  [07:16:40.758] Packages needed by future strategies (n = 0): <none>
  [07:16:40.763] {
  [07:16:40.763]     {
  [07:16:40.763]         ...future.startTime <- base::Sys.time()
  [07:16:40.763]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.763]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.763]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:16:40.763]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.763]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.763]         {
  [07:16:40.763]             {
  [07:16:40.763]                 base::local({
  [07:16:40.763]                   has_future <- base::requireNamespace("future", 
  [07:16:40.763]                     quietly = TRUE)
  [07:16:40.763]                   version <- if (has_future) 
  [07:16:40.763]                     utils::packageVersion("future")
  [07:16:40.763]                   else NULL
  [07:16:40.763]                   if (!has_future || version < "1.8.0") {
  [07:16:40.763]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.763]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.763]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.763]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.763]                         "release", "version")], collapse = " "), 
  [07:16:40.763]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.763]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.763]                       info)
  [07:16:40.763]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.763]                     if (!has_future) {
  [07:16:40.763]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.763]                         info)
  [07:16:40.763]                     }
  [07:16:40.763]                     else {
  [07:16:40.763]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.763]                         info, version)
  [07:16:40.763]                     }
  [07:16:40.763]                     base::stop(msg)
  [07:16:40.763]                   }
  [07:16:40.763]                 })
  [07:16:40.763]             }
  [07:16:40.763]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.763]         }
  [07:16:40.763]     }
  [07:16:40.763]     if (base::is.na(NA)) {
  [07:16:40.763]     }
  [07:16:40.763]     else {
  [07:16:40.763]         if (NA) {
  [07:16:40.763]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.763]                 open = "w")
  [07:16:40.763]         }
  [07:16:40.763]         else {
  [07:16:40.763]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.763]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.763]         }
  [07:16:40.763]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.763]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.763]             base::sink(type = "output", split = FALSE)
  [07:16:40.763]             base::close(...future.stdout)
  [07:16:40.763]         }, add = TRUE)
  [07:16:40.763]     }
  [07:16:40.763]     ...future.frame <- base::sys.nframe()
  [07:16:40.763]     ...future.conditions <- base::list()
  [07:16:40.763]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.763]     ...future.result <- base::tryCatch({
  [07:16:40.763]         base::withCallingHandlers({
  [07:16:40.763]             ...future.value <- base::withVisible(base::local({
  [07:16:40.763]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.763]             }))
  [07:16:40.763]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.763]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.763]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.763]                 version = "1.8")
  [07:16:40.763]         }, condition = base::local({
  [07:16:40.763]             c <- base::c
  [07:16:40.763]             inherits <- base::inherits
  [07:16:40.763]             invokeRestart <- base::invokeRestart
  [07:16:40.763]             length <- base::length
  [07:16:40.763]             list <- base::list
  [07:16:40.763]             seq.int <- base::seq.int
  [07:16:40.763]             signalCondition <- base::signalCondition
  [07:16:40.763]             sys.calls <- base::sys.calls
  [07:16:40.763]             Sys.time <- base::Sys.time
  [07:16:40.763]             `[[` <- base::`[[`
  [07:16:40.763]             `+` <- base::`+`
  [07:16:40.763]             `<<-` <- base::`<<-`
  [07:16:40.763]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.763]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.763]                   3L)]
  [07:16:40.763]             }
  [07:16:40.763]             function(cond) {
  [07:16:40.763]                 if (inherits(cond, "error")) {
  [07:16:40.763]                   sessionInformation <- function() {
  [07:16:40.763]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.763]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.763]                       search = base::search(), system = base::Sys.info())
  [07:16:40.763]                   }
  [07:16:40.763]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.763]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.763]                     cond$call), session = sessionInformation(), 
  [07:16:40.763]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.763]                   signalCondition(cond)
  [07:16:40.763]                 }
  [07:16:40.763]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.763]                 ))) {
  [07:16:40.763]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.763]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.763]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.763]                   if (!signal) {
  [07:16:40.763]                     muffleCondition <- function (cond) 
  [07:16:40.763]                     {
  [07:16:40.763]                       inherits <- base::inherits
  [07:16:40.763]                       invokeRestart <- base::invokeRestart
  [07:16:40.763]                       muffled <- FALSE
  [07:16:40.763]                       if (inherits(cond, "message")) {
  [07:16:40.763]                         invokeRestart("muffleMessage")
  [07:16:40.763]                         muffled <- TRUE
  [07:16:40.763]                       }
  [07:16:40.763]                       else if (inherits(cond, "warning")) {
  [07:16:40.763]                         invokeRestart("muffleWarning")
  [07:16:40.763]                         muffled <- TRUE
  [07:16:40.763]                       }
  [07:16:40.763]                       else if (inherits(cond, "condition")) {
  [07:16:40.763]                         computeRestarts <- base::computeRestarts
  [07:16:40.763]                         grepl <- base::grepl
  [07:16:40.763]                         is.null <- base::is.null
  [07:16:40.763]                         restarts <- computeRestarts(cond)
  [07:16:40.763]                         for (restart in restarts) {
  [07:16:40.763]                           name <- restart$name
  [07:16:40.763]                           if (is.null(name)) 
  [07:16:40.763]                             next
  [07:16:40.763]                           if (!grepl("^muffle", name)) 
  [07:16:40.763]                             next
  [07:16:40.763]                           invokeRestart(restart)
  [07:16:40.763]                           muffled <- TRUE
  [07:16:40.763]                           break
  [07:16:40.763]                         }
  [07:16:40.763]                       }
  [07:16:40.763]                       invisible(muffled)
  [07:16:40.763]                     }
  [07:16:40.763]                     muffleCondition(cond)
  [07:16:40.763]                   }
  [07:16:40.763]                 }
  [07:16:40.763]             }
  [07:16:40.763]         }))
  [07:16:40.763]     }, error = function(ex) {
  [07:16:40.763]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.763]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.763]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.763]     }, finally = {
  [07:16:40.763]         {
  [07:16:40.763]             NULL
  [07:16:40.763]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.763]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.763]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.763]                 label = NULL, ...) 
  [07:16:40.763]             {
  [07:16:40.763]                 if (substitute) 
  [07:16:40.763]                   expr <- substitute(expr)
  [07:16:40.763]                 local <- as.logical(local)
  [07:16:40.763]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.763]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.763]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.763]                   label = label, ...)
  [07:16:40.763]                 if (!future$lazy) 
  [07:16:40.763]                   future <- run(future)
  [07:16:40.763]                 invisible(future)
  [07:16:40.763]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.763]         }
  [07:16:40.763]         base::options(...future.oldOptions)
  [07:16:40.763]     })
  [07:16:40.763]     Sys.time
  [07:16:40.763]     if (base::is.na(NA)) {
  [07:16:40.763]     }
  [07:16:40.763]     else {
  [07:16:40.763]         base::sink(type = "output", split = FALSE)
  [07:16:40.763]         if (NA) {
  [07:16:40.763]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.763]         }
  [07:16:40.763]         else {
  [07:16:40.763]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.763]         }
  [07:16:40.763]         base::close(...future.stdout)
  [07:16:40.763]         ...future.stdout <- NULL
  [07:16:40.763]     }
  [07:16:40.763]     ...future.result$conditions <- ...future.conditions
  [07:16:40.763]     ...future.result
  [07:16:40.763] }
  [07:16:40.767] plan(): Setting new future strategy stack:
  [07:16:40.768] List of future strategies:
  [07:16:40.768] 1. sequential:
  [07:16:40.768]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.768]    - tweaked: FALSE
  [07:16:40.768]    - call: NULL
  [07:16:40.768] plan(): nbrOfWorkers() = 1
  [07:16:40.770] Packages needed by the future expression (n = 0): <none>
  [07:16:40.770] Packages needed by future strategies (n = 0): <none>
  [07:16:40.773] {
  [07:16:40.773]     {
  [07:16:40.773]         ...future.startTime <- base::Sys.time()
  [07:16:40.773]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.773]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.773]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:16:40.773]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.773]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.773]         {
  [07:16:40.773]             {
  [07:16:40.773]                 base::local({
  [07:16:40.773]                   has_future <- base::requireNamespace("future", 
  [07:16:40.773]                     quietly = TRUE)
  [07:16:40.773]                   version <- if (has_future) 
  [07:16:40.773]                     utils::packageVersion("future")
  [07:16:40.773]                   else NULL
  [07:16:40.773]                   if (!has_future || version < "1.8.0") {
  [07:16:40.773]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.773]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.773]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.773]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.773]                         "release", "version")], collapse = " "), 
  [07:16:40.773]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.773]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.773]                       info)
  [07:16:40.773]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.773]                     if (!has_future) {
  [07:16:40.773]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.773]                         info)
  [07:16:40.773]                     }
  [07:16:40.773]                     else {
  [07:16:40.773]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.773]                         info, version)
  [07:16:40.773]                     }
  [07:16:40.773]                     base::stop(msg)
  [07:16:40.773]                   }
  [07:16:40.773]                 })
  [07:16:40.773]             }
  [07:16:40.773]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.773]         }
  [07:16:40.773]     }
  [07:16:40.773]     if (base::is.na(NA)) {
  [07:16:40.773]     }
  [07:16:40.773]     else {
  [07:16:40.773]         if (NA) {
  [07:16:40.773]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.773]                 open = "w")
  [07:16:40.773]         }
  [07:16:40.773]         else {
  [07:16:40.773]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.773]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.773]         }
  [07:16:40.773]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.773]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.773]             base::sink(type = "output", split = FALSE)
  [07:16:40.773]             base::close(...future.stdout)
  [07:16:40.773]         }, add = TRUE)
  [07:16:40.773]     }
  [07:16:40.773]     ...future.frame <- base::sys.nframe()
  [07:16:40.773]     ...future.conditions <- base::list()
  [07:16:40.773]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.773]     ...future.result <- base::tryCatch({
  [07:16:40.773]         base::withCallingHandlers({
  [07:16:40.773]             ...future.value <- base::withVisible(base::local({
  [07:16:40.773]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.773]             }))
  [07:16:40.773]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.773]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.773]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.773]                 version = "1.8")
  [07:16:40.773]         }, condition = base::local({
  [07:16:40.773]             c <- base::c
  [07:16:40.773]             inherits <- base::inherits
  [07:16:40.773]             invokeRestart <- base::invokeRestart
  [07:16:40.773]             length <- base::length
  [07:16:40.773]             list <- base::list
  [07:16:40.773]             seq.int <- base::seq.int
  [07:16:40.773]             signalCondition <- base::signalCondition
  [07:16:40.773]             sys.calls <- base::sys.calls
  [07:16:40.773]             Sys.time <- base::Sys.time
  [07:16:40.773]             `[[` <- base::`[[`
  [07:16:40.773]             `+` <- base::`+`
  [07:16:40.773]             `<<-` <- base::`<<-`
  [07:16:40.773]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.773]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.773]                   3L)]
  [07:16:40.773]             }
  [07:16:40.773]             function(cond) {
  [07:16:40.773]                 if (inherits(cond, "error")) {
  [07:16:40.773]                   sessionInformation <- function() {
  [07:16:40.773]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.773]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.773]                       search = base::search(), system = base::Sys.info())
  [07:16:40.773]                   }
  [07:16:40.773]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.773]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.773]                     cond$call), session = sessionInformation(), 
  [07:16:40.773]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.773]                   signalCondition(cond)
  [07:16:40.773]                 }
  [07:16:40.773]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.773]                 ))) {
  [07:16:40.773]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.773]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.773]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.773]                   if (!signal) {
  [07:16:40.773]                     muffleCondition <- function (cond) 
  [07:16:40.773]                     {
  [07:16:40.773]                       inherits <- base::inherits
  [07:16:40.773]                       invokeRestart <- base::invokeRestart
  [07:16:40.773]                       muffled <- FALSE
  [07:16:40.773]                       if (inherits(cond, "message")) {
  [07:16:40.773]                         invokeRestart("muffleMessage")
  [07:16:40.773]                         muffled <- TRUE
  [07:16:40.773]                       }
  [07:16:40.773]                       else if (inherits(cond, "warning")) {
  [07:16:40.773]                         invokeRestart("muffleWarning")
  [07:16:40.773]                         muffled <- TRUE
  [07:16:40.773]                       }
  [07:16:40.773]                       else if (inherits(cond, "condition")) {
  [07:16:40.773]                         computeRestarts <- base::computeRestarts
  [07:16:40.773]                         grepl <- base::grepl
  [07:16:40.773]                         is.null <- base::is.null
  [07:16:40.773]                         restarts <- computeRestarts(cond)
  [07:16:40.773]                         for (restart in restarts) {
  [07:16:40.773]                           name <- restart$name
  [07:16:40.773]                           if (is.null(name)) 
  [07:16:40.773]                             next
  [07:16:40.773]                           if (!grepl("^muffle", name)) 
  [07:16:40.773]                             next
  [07:16:40.773]                           invokeRestart(restart)
  [07:16:40.773]                           muffled <- TRUE
  [07:16:40.773]                           break
  [07:16:40.773]                         }
  [07:16:40.773]                       }
  [07:16:40.773]                       invisible(muffled)
  [07:16:40.773]                     }
  [07:16:40.773]                     muffleCondition(cond)
  [07:16:40.773]                   }
  [07:16:40.773]                 }
  [07:16:40.773]             }
  [07:16:40.773]         }))
  [07:16:40.773]     }, error = function(ex) {
  [07:16:40.773]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.773]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.773]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.773]     }, finally = {
  [07:16:40.773]         {
  [07:16:40.773]             NULL
  [07:16:40.773]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.773]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.773]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.773]                 label = NULL, ...) 
  [07:16:40.773]             {
  [07:16:40.773]                 if (substitute) 
  [07:16:40.773]                   expr <- substitute(expr)
  [07:16:40.773]                 local <- as.logical(local)
  [07:16:40.773]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.773]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.773]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.773]                   label = label, ...)
  [07:16:40.773]                 if (!future$lazy) 
  [07:16:40.773]                   future <- run(future)
  [07:16:40.773]                 invisible(future)
  [07:16:40.773]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.773]         }
  [07:16:40.773]         base::options(...future.oldOptions)
  [07:16:40.773]     })
  [07:16:40.773]     Sys.time
  [07:16:40.773]     if (base::is.na(NA)) {
  [07:16:40.773]     }
  [07:16:40.773]     else {
  [07:16:40.773]         base::sink(type = "output", split = FALSE)
  [07:16:40.773]         if (NA) {
  [07:16:40.773]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.773]         }
  [07:16:40.773]         else {
  [07:16:40.773]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.773]         }
  [07:16:40.773]         base::close(...future.stdout)
  [07:16:40.773]         ...future.stdout <- NULL
  [07:16:40.773]     }
  [07:16:40.773]     ...future.result$conditions <- ...future.conditions
  [07:16:40.773]     ...future.result
  [07:16:40.773] }
  [07:16:40.777] plan(): Setting new future strategy stack:
  [07:16:40.777] List of future strategies:
  [07:16:40.777] 1. sequential:
  [07:16:40.777]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.777]    - tweaked: FALSE
  [07:16:40.777]    - call: NULL
  [07:16:40.778] plan(): nbrOfWorkers() = 1
  [07:16:40.780] Packages needed by the future expression (n = 0): <none>
  [07:16:40.780] Packages needed by future strategies (n = 0): <none>
  [07:16:40.783] {
  [07:16:40.783]     {
  [07:16:40.783]         ...future.startTime <- base::Sys.time()
  [07:16:40.783]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.783]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.783]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:16:40.783]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.783]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.783]         {
  [07:16:40.783]             {
  [07:16:40.783]                 base::local({
  [07:16:40.783]                   has_future <- base::requireNamespace("future", 
  [07:16:40.783]                     quietly = TRUE)
  [07:16:40.783]                   version <- if (has_future) 
  [07:16:40.783]                     utils::packageVersion("future")
  [07:16:40.783]                   else NULL
  [07:16:40.783]                   if (!has_future || version < "1.8.0") {
  [07:16:40.783]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.783]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.783]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.783]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.783]                         "release", "version")], collapse = " "), 
  [07:16:40.783]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.783]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.783]                       info)
  [07:16:40.783]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.783]                     if (!has_future) {
  [07:16:40.783]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.783]                         info)
  [07:16:40.783]                     }
  [07:16:40.783]                     else {
  [07:16:40.783]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.783]                         info, version)
  [07:16:40.783]                     }
  [07:16:40.783]                     base::stop(msg)
  [07:16:40.783]                   }
  [07:16:40.783]                 })
  [07:16:40.783]             }
  [07:16:40.783]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.783]         }
  [07:16:40.783]     }
  [07:16:40.783]     if (base::is.na(NA)) {
  [07:16:40.783]     }
  [07:16:40.783]     else {
  [07:16:40.783]         if (NA) {
  [07:16:40.783]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.783]                 open = "w")
  [07:16:40.783]         }
  [07:16:40.783]         else {
  [07:16:40.783]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.783]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.783]         }
  [07:16:40.783]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.783]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.783]             base::sink(type = "output", split = FALSE)
  [07:16:40.783]             base::close(...future.stdout)
  [07:16:40.783]         }, add = TRUE)
  [07:16:40.783]     }
  [07:16:40.783]     ...future.frame <- base::sys.nframe()
  [07:16:40.783]     ...future.conditions <- base::list()
  [07:16:40.783]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.783]     ...future.result <- base::tryCatch({
  [07:16:40.783]         base::withCallingHandlers({
  [07:16:40.783]             ...future.value <- base::withVisible(base::local({
  [07:16:40.783]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.783]             }))
  [07:16:40.783]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.783]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.783]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.783]                 version = "1.8")
  [07:16:40.783]         }, condition = base::local({
  [07:16:40.783]             c <- base::c
  [07:16:40.783]             inherits <- base::inherits
  [07:16:40.783]             invokeRestart <- base::invokeRestart
  [07:16:40.783]             length <- base::length
  [07:16:40.783]             list <- base::list
  [07:16:40.783]             seq.int <- base::seq.int
  [07:16:40.783]             signalCondition <- base::signalCondition
  [07:16:40.783]             sys.calls <- base::sys.calls
  [07:16:40.783]             Sys.time <- base::Sys.time
  [07:16:40.783]             `[[` <- base::`[[`
  [07:16:40.783]             `+` <- base::`+`
  [07:16:40.783]             `<<-` <- base::`<<-`
  [07:16:40.783]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.783]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.783]                   3L)]
  [07:16:40.783]             }
  [07:16:40.783]             function(cond) {
  [07:16:40.783]                 if (inherits(cond, "error")) {
  [07:16:40.783]                   sessionInformation <- function() {
  [07:16:40.783]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.783]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.783]                       search = base::search(), system = base::Sys.info())
  [07:16:40.783]                   }
  [07:16:40.783]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.783]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.783]                     cond$call), session = sessionInformation(), 
  [07:16:40.783]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.783]                   signalCondition(cond)
  [07:16:40.783]                 }
  [07:16:40.783]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.783]                 ))) {
  [07:16:40.783]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.783]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.783]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.783]                   if (!signal) {
  [07:16:40.783]                     muffleCondition <- function (cond) 
  [07:16:40.783]                     {
  [07:16:40.783]                       inherits <- base::inherits
  [07:16:40.783]                       invokeRestart <- base::invokeRestart
  [07:16:40.783]                       muffled <- FALSE
  [07:16:40.783]                       if (inherits(cond, "message")) {
  [07:16:40.783]                         invokeRestart("muffleMessage")
  [07:16:40.783]                         muffled <- TRUE
  [07:16:40.783]                       }
  [07:16:40.783]                       else if (inherits(cond, "warning")) {
  [07:16:40.783]                         invokeRestart("muffleWarning")
  [07:16:40.783]                         muffled <- TRUE
  [07:16:40.783]                       }
  [07:16:40.783]                       else if (inherits(cond, "condition")) {
  [07:16:40.783]                         computeRestarts <- base::computeRestarts
  [07:16:40.783]                         grepl <- base::grepl
  [07:16:40.783]                         is.null <- base::is.null
  [07:16:40.783]                         restarts <- computeRestarts(cond)
  [07:16:40.783]                         for (restart in restarts) {
  [07:16:40.783]                           name <- restart$name
  [07:16:40.783]                           if (is.null(name)) 
  [07:16:40.783]                             next
  [07:16:40.783]                           if (!grepl("^muffle", name)) 
  [07:16:40.783]                             next
  [07:16:40.783]                           invokeRestart(restart)
  [07:16:40.783]                           muffled <- TRUE
  [07:16:40.783]                           break
  [07:16:40.783]                         }
  [07:16:40.783]                       }
  [07:16:40.783]                       invisible(muffled)
  [07:16:40.783]                     }
  [07:16:40.783]                     muffleCondition(cond)
  [07:16:40.783]                   }
  [07:16:40.783]                 }
  [07:16:40.783]             }
  [07:16:40.783]         }))
  [07:16:40.783]     }, error = function(ex) {
  [07:16:40.783]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.783]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.783]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.783]     }, finally = {
  [07:16:40.783]         {
  [07:16:40.783]             NULL
  [07:16:40.783]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.783]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.783]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.783]                 label = NULL, ...) 
  [07:16:40.783]             {
  [07:16:40.783]                 if (substitute) 
  [07:16:40.783]                   expr <- substitute(expr)
  [07:16:40.783]                 local <- as.logical(local)
  [07:16:40.783]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.783]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.783]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.783]                   label = label, ...)
  [07:16:40.783]                 if (!future$lazy) 
  [07:16:40.783]                   future <- run(future)
  [07:16:40.783]                 invisible(future)
  [07:16:40.783]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.783]         }
  [07:16:40.783]         base::options(...future.oldOptions)
  [07:16:40.783]     })
  [07:16:40.783]     Sys.time
  [07:16:40.783]     if (base::is.na(NA)) {
  [07:16:40.783]     }
  [07:16:40.783]     else {
  [07:16:40.783]         base::sink(type = "output", split = FALSE)
  [07:16:40.783]         if (NA) {
  [07:16:40.783]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.783]         }
  [07:16:40.783]         else {
  [07:16:40.783]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.783]         }
  [07:16:40.783]         base::close(...future.stdout)
  [07:16:40.783]         ...future.stdout <- NULL
  [07:16:40.783]     }
  [07:16:40.783]     ...future.result$conditions <- ...future.conditions
  [07:16:40.783]     ...future.result
  [07:16:40.783] }
  [07:16:40.787] plan(): Setting new future strategy stack:
  [07:16:40.787] List of future strategies:
  [07:16:40.787] 1. sequential:
  [07:16:40.787]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.787]    - tweaked: FALSE
  [07:16:40.787]    - call: NULL
  [07:16:40.788] plan(): nbrOfWorkers() = 1
  [07:16:40.789] plan(): Setting new future strategy stack:
  [07:16:40.790] List of future strategies:
  [07:16:40.790] 1. sequential:
  [07:16:40.790]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.790]    - tweaked: FALSE
  [07:16:40.790]    - call: NULL
  [07:16:40.790] plan(): nbrOfWorkers() = 1
  [07:16:40.791] SequentialFuture started (and completed)
  [07:16:40.793] Packages needed by the future expression (n = 0): <none>
  [07:16:40.793] Packages needed by future strategies (n = 0): <none>
  [07:16:40.797] {
  [07:16:40.797]     {
  [07:16:40.797]         ...future.startTime <- base::Sys.time()
  [07:16:40.797]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.797]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.797]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.797]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.797]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.797]         {
  [07:16:40.797]             {
  [07:16:40.797]                 base::local({
  [07:16:40.797]                   has_future <- base::requireNamespace("future", 
  [07:16:40.797]                     quietly = TRUE)
  [07:16:40.797]                   version <- if (has_future) 
  [07:16:40.797]                     utils::packageVersion("future")
  [07:16:40.797]                   else NULL
  [07:16:40.797]                   if (!has_future || version < "1.8.0") {
  [07:16:40.797]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.797]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.797]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.797]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.797]                         "release", "version")], collapse = " "), 
  [07:16:40.797]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.797]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.797]                       info)
  [07:16:40.797]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.797]                     if (!has_future) {
  [07:16:40.797]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.797]                         info)
  [07:16:40.797]                     }
  [07:16:40.797]                     else {
  [07:16:40.797]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.797]                         info, version)
  [07:16:40.797]                     }
  [07:16:40.797]                     base::stop(msg)
  [07:16:40.797]                   }
  [07:16:40.797]                 })
  [07:16:40.797]             }
  [07:16:40.797]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.797]         }
  [07:16:40.797]     }
  [07:16:40.797]     if (base::is.na(NA)) {
  [07:16:40.797]     }
  [07:16:40.797]     else {
  [07:16:40.797]         if (NA) {
  [07:16:40.797]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.797]                 open = "w")
  [07:16:40.797]         }
  [07:16:40.797]         else {
  [07:16:40.797]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.797]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.797]         }
  [07:16:40.797]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.797]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.797]             base::sink(type = "output", split = FALSE)
  [07:16:40.797]             base::close(...future.stdout)
  [07:16:40.797]         }, add = TRUE)
  [07:16:40.797]     }
  [07:16:40.797]     ...future.frame <- base::sys.nframe()
  [07:16:40.797]     ...future.conditions <- base::list()
  [07:16:40.797]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.797]     ...future.result <- base::tryCatch({
  [07:16:40.797]         base::withCallingHandlers({
  [07:16:40.797]             ...future.value <- base::withVisible(base::local({
  [07:16:40.797]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.797]             }))
  [07:16:40.797]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.797]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.797]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.797]                 version = "1.8")
  [07:16:40.797]         }, condition = base::local({
  [07:16:40.797]             c <- base::c
  [07:16:40.797]             inherits <- base::inherits
  [07:16:40.797]             invokeRestart <- base::invokeRestart
  [07:16:40.797]             length <- base::length
  [07:16:40.797]             list <- base::list
  [07:16:40.797]             seq.int <- base::seq.int
  [07:16:40.797]             signalCondition <- base::signalCondition
  [07:16:40.797]             sys.calls <- base::sys.calls
  [07:16:40.797]             Sys.time <- base::Sys.time
  [07:16:40.797]             `[[` <- base::`[[`
  [07:16:40.797]             `+` <- base::`+`
  [07:16:40.797]             `<<-` <- base::`<<-`
  [07:16:40.797]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.797]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.797]                   3L)]
  [07:16:40.797]             }
  [07:16:40.797]             function(cond) {
  [07:16:40.797]                 if (inherits(cond, "error")) {
  [07:16:40.797]                   sessionInformation <- function() {
  [07:16:40.797]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.797]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.797]                       search = base::search(), system = base::Sys.info())
  [07:16:40.797]                   }
  [07:16:40.797]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.797]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.797]                     cond$call), session = sessionInformation(), 
  [07:16:40.797]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.797]                   signalCondition(cond)
  [07:16:40.797]                 }
  [07:16:40.797]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.797]                 ))) {
  [07:16:40.797]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.797]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.797]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.797]                   if (!signal) {
  [07:16:40.797]                     muffleCondition <- function (cond) 
  [07:16:40.797]                     {
  [07:16:40.797]                       inherits <- base::inherits
  [07:16:40.797]                       invokeRestart <- base::invokeRestart
  [07:16:40.797]                       muffled <- FALSE
  [07:16:40.797]                       if (inherits(cond, "message")) {
  [07:16:40.797]                         invokeRestart("muffleMessage")
  [07:16:40.797]                         muffled <- TRUE
  [07:16:40.797]                       }
  [07:16:40.797]                       else if (inherits(cond, "warning")) {
  [07:16:40.797]                         invokeRestart("muffleWarning")
  [07:16:40.797]                         muffled <- TRUE
  [07:16:40.797]                       }
  [07:16:40.797]                       else if (inherits(cond, "condition")) {
  [07:16:40.797]                         computeRestarts <- base::computeRestarts
  [07:16:40.797]                         grepl <- base::grepl
  [07:16:40.797]                         is.null <- base::is.null
  [07:16:40.797]                         restarts <- computeRestarts(cond)
  [07:16:40.797]                         for (restart in restarts) {
  [07:16:40.797]                           name <- restart$name
  [07:16:40.797]                           if (is.null(name)) 
  [07:16:40.797]                             next
  [07:16:40.797]                           if (!grepl("^muffle", name)) 
  [07:16:40.797]                             next
  [07:16:40.797]                           invokeRestart(restart)
  [07:16:40.797]                           muffled <- TRUE
  [07:16:40.797]                           break
  [07:16:40.797]                         }
  [07:16:40.797]                       }
  [07:16:40.797]                       invisible(muffled)
  [07:16:40.797]                     }
  [07:16:40.797]                     muffleCondition(cond)
  [07:16:40.797]                   }
  [07:16:40.797]                 }
  [07:16:40.797]             }
  [07:16:40.797]         }))
  [07:16:40.797]     }, error = function(ex) {
  [07:16:40.797]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.797]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.797]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.797]     }, finally = {
  [07:16:40.797]         {
  [07:16:40.797]             NULL
  [07:16:40.797]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.797]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.797]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.797]                 label = NULL, ...) 
  [07:16:40.797]             {
  [07:16:40.797]                 if (substitute) 
  [07:16:40.797]                   expr <- substitute(expr)
  [07:16:40.797]                 local <- as.logical(local)
  [07:16:40.797]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.797]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.797]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.797]                   label = label, ...)
  [07:16:40.797]                 if (!future$lazy) 
  [07:16:40.797]                   future <- run(future)
  [07:16:40.797]                 invisible(future)
  [07:16:40.797]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.797]         }
  [07:16:40.797]         base::options(...future.oldOptions)
  [07:16:40.797]     })
  [07:16:40.797]     Sys.time
  [07:16:40.797]     if (base::is.na(NA)) {
  [07:16:40.797]     }
  [07:16:40.797]     else {
  [07:16:40.797]         base::sink(type = "output", split = FALSE)
  [07:16:40.797]         if (NA) {
  [07:16:40.797]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.797]         }
  [07:16:40.797]         else {
  [07:16:40.797]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.797]         }
  [07:16:40.797]         base::close(...future.stdout)
  [07:16:40.797]         ...future.stdout <- NULL
  [07:16:40.797]     }
  [07:16:40.797]     ...future.result$conditions <- ...future.conditions
  [07:16:40.797]     ...future.result
  [07:16:40.797] }
  [07:16:40.800] plan(): Setting new future strategy stack:
  [07:16:40.801] List of future strategies:
  [07:16:40.801] 1. sequential:
  [07:16:40.801]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.801]    - tweaked: FALSE
  [07:16:40.801]    - call: NULL
  [07:16:40.801] plan(): nbrOfWorkers() = 1
  [07:16:40.802] plan(): Setting new future strategy stack:
  [07:16:40.803] List of future strategies:
  [07:16:40.803] 1. sequential:
  [07:16:40.803]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.803]    - tweaked: FALSE
  [07:16:40.803]    - call: NULL
  [07:16:40.803] plan(): nbrOfWorkers() = 1
  [07:16:40.804] SequentialFuture started (and completed)
  [07:16:40.805] plan(): Setting new future strategy stack:
  [07:16:40.805] List of future strategies:
  [07:16:40.805] 1. sequential:
  [07:16:40.805]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.805]    - tweaked: FALSE
  [07:16:40.805]    - call: NULL
  [07:16:40.806] plan(): nbrOfWorkers() = 1
  [07:16:40.806] SequentialFuture started (and completed)
  [07:16:40.807] Packages needed by the future expression (n = 0): <none>
  [07:16:40.808] Packages needed by future strategies (n = 0): <none>
  [07:16:40.811] {
  [07:16:40.811]     {
  [07:16:40.811]         ...future.startTime <- base::Sys.time()
  [07:16:40.811]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.811]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.811]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.811]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.811]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.811]         {
  [07:16:40.811]             {
  [07:16:40.811]                 base::local({
  [07:16:40.811]                   has_future <- base::requireNamespace("future", 
  [07:16:40.811]                     quietly = TRUE)
  [07:16:40.811]                   version <- if (has_future) 
  [07:16:40.811]                     utils::packageVersion("future")
  [07:16:40.811]                   else NULL
  [07:16:40.811]                   if (!has_future || version < "1.8.0") {
  [07:16:40.811]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.811]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.811]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.811]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.811]                         "release", "version")], collapse = " "), 
  [07:16:40.811]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.811]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.811]                       info)
  [07:16:40.811]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.811]                     if (!has_future) {
  [07:16:40.811]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.811]                         info)
  [07:16:40.811]                     }
  [07:16:40.811]                     else {
  [07:16:40.811]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.811]                         info, version)
  [07:16:40.811]                     }
  [07:16:40.811]                     base::stop(msg)
  [07:16:40.811]                   }
  [07:16:40.811]                 })
  [07:16:40.811]             }
  [07:16:40.811]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.811]         }
  [07:16:40.811]     }
  [07:16:40.811]     if (base::is.na(NA)) {
  [07:16:40.811]     }
  [07:16:40.811]     else {
  [07:16:40.811]         if (NA) {
  [07:16:40.811]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.811]                 open = "w")
  [07:16:40.811]         }
  [07:16:40.811]         else {
  [07:16:40.811]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.811]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.811]         }
  [07:16:40.811]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.811]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.811]             base::sink(type = "output", split = FALSE)
  [07:16:40.811]             base::close(...future.stdout)
  [07:16:40.811]         }, add = TRUE)
  [07:16:40.811]     }
  [07:16:40.811]     ...future.frame <- base::sys.nframe()
  [07:16:40.811]     ...future.conditions <- base::list()
  [07:16:40.811]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.811]     ...future.result <- base::tryCatch({
  [07:16:40.811]         base::withCallingHandlers({
  [07:16:40.811]             ...future.value <- base::withVisible(base::local({
  [07:16:40.811]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.811]             }))
  [07:16:40.811]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.811]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.811]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.811]                 version = "1.8")
  [07:16:40.811]         }, condition = base::local({
  [07:16:40.811]             c <- base::c
  [07:16:40.811]             inherits <- base::inherits
  [07:16:40.811]             invokeRestart <- base::invokeRestart
  [07:16:40.811]             length <- base::length
  [07:16:40.811]             list <- base::list
  [07:16:40.811]             seq.int <- base::seq.int
  [07:16:40.811]             signalCondition <- base::signalCondition
  [07:16:40.811]             sys.calls <- base::sys.calls
  [07:16:40.811]             Sys.time <- base::Sys.time
  [07:16:40.811]             `[[` <- base::`[[`
  [07:16:40.811]             `+` <- base::`+`
  [07:16:40.811]             `<<-` <- base::`<<-`
  [07:16:40.811]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.811]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.811]                   3L)]
  [07:16:40.811]             }
  [07:16:40.811]             function(cond) {
  [07:16:40.811]                 if (inherits(cond, "error")) {
  [07:16:40.811]                   sessionInformation <- function() {
  [07:16:40.811]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.811]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.811]                       search = base::search(), system = base::Sys.info())
  [07:16:40.811]                   }
  [07:16:40.811]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.811]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.811]                     cond$call), session = sessionInformation(), 
  [07:16:40.811]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.811]                   signalCondition(cond)
  [07:16:40.811]                 }
  [07:16:40.811]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.811]                 ))) {
  [07:16:40.811]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.811]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.811]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.811]                   if (!signal) {
  [07:16:40.811]                     muffleCondition <- function (cond) 
  [07:16:40.811]                     {
  [07:16:40.811]                       inherits <- base::inherits
  [07:16:40.811]                       invokeRestart <- base::invokeRestart
  [07:16:40.811]                       muffled <- FALSE
  [07:16:40.811]                       if (inherits(cond, "message")) {
  [07:16:40.811]                         invokeRestart("muffleMessage")
  [07:16:40.811]                         muffled <- TRUE
  [07:16:40.811]                       }
  [07:16:40.811]                       else if (inherits(cond, "warning")) {
  [07:16:40.811]                         invokeRestart("muffleWarning")
  [07:16:40.811]                         muffled <- TRUE
  [07:16:40.811]                       }
  [07:16:40.811]                       else if (inherits(cond, "condition")) {
  [07:16:40.811]                         computeRestarts <- base::computeRestarts
  [07:16:40.811]                         grepl <- base::grepl
  [07:16:40.811]                         is.null <- base::is.null
  [07:16:40.811]                         restarts <- computeRestarts(cond)
  [07:16:40.811]                         for (restart in restarts) {
  [07:16:40.811]                           name <- restart$name
  [07:16:40.811]                           if (is.null(name)) 
  [07:16:40.811]                             next
  [07:16:40.811]                           if (!grepl("^muffle", name)) 
  [07:16:40.811]                             next
  [07:16:40.811]                           invokeRestart(restart)
  [07:16:40.811]                           muffled <- TRUE
  [07:16:40.811]                           break
  [07:16:40.811]                         }
  [07:16:40.811]                       }
  [07:16:40.811]                       invisible(muffled)
  [07:16:40.811]                     }
  [07:16:40.811]                     muffleCondition(cond)
  [07:16:40.811]                   }
  [07:16:40.811]                 }
  [07:16:40.811]             }
  [07:16:40.811]         }))
  [07:16:40.811]     }, error = function(ex) {
  [07:16:40.811]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.811]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.811]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.811]     }, finally = {
  [07:16:40.811]         {
  [07:16:40.811]             NULL
  [07:16:40.811]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.811]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.811]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.811]                 label = NULL, ...) 
  [07:16:40.811]             {
  [07:16:40.811]                 if (substitute) 
  [07:16:40.811]                   expr <- substitute(expr)
  [07:16:40.811]                 local <- as.logical(local)
  [07:16:40.811]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.811]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.811]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.811]                   label = label, ...)
  [07:16:40.811]                 if (!future$lazy) 
  [07:16:40.811]                   future <- run(future)
  [07:16:40.811]                 invisible(future)
  [07:16:40.811]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.811]         }
  [07:16:40.811]         base::options(...future.oldOptions)
  [07:16:40.811]     })
  [07:16:40.811]     Sys.time
  [07:16:40.811]     if (base::is.na(NA)) {
  [07:16:40.811]     }
  [07:16:40.811]     else {
  [07:16:40.811]         base::sink(type = "output", split = FALSE)
  [07:16:40.811]         if (NA) {
  [07:16:40.811]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.811]         }
  [07:16:40.811]         else {
  [07:16:40.811]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.811]         }
  [07:16:40.811]         base::close(...future.stdout)
  [07:16:40.811]         ...future.stdout <- NULL
  [07:16:40.811]     }
  [07:16:40.811]     ...future.result$conditions <- ...future.conditions
  [07:16:40.811]     ...future.result
  [07:16:40.811] }
  [07:16:40.814] plan(): Setting new future strategy stack:
  [07:16:40.815] List of future strategies:
  [07:16:40.815] 1. sequential:
  [07:16:40.815]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.815]    - tweaked: FALSE
  [07:16:40.815]    - call: NULL
  [07:16:40.817] plan(): nbrOfWorkers() = 1
  [07:16:40.818] plan(): Setting new future strategy stack:
  [07:16:40.819] List of future strategies:
  [07:16:40.819] 1. sequential:
  [07:16:40.819]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.819]    - tweaked: FALSE
  [07:16:40.819]    - call: NULL
  [07:16:40.819] plan(): nbrOfWorkers() = 1
  [07:16:40.820] SequentialFuture started (and completed)
  [07:16:40.820] plan(): Setting new future strategy stack:
  [07:16:40.821] List of future strategies:
  [07:16:40.821] 1. sequential:
  [07:16:40.821]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.821]    - tweaked: FALSE
  [07:16:40.821]    - call: plan(sequential)
  [07:16:40.821] plan(): nbrOfWorkers() = 1
  [07:16:40.822] 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:16:40.823] Packages needed by the future expression (n = 0): <none>
  [07:16:40.824] Packages needed by future strategies (n = 0): <none>
  [07:16:40.827] {
  [07:16:40.827]     {
  [07:16:40.827]         ...future.startTime <- base::Sys.time()
  [07:16:40.827]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.827]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.827]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.827]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.827]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.827]         {
  [07:16:40.827]             {
  [07:16:40.827]                 base::local({
  [07:16:40.827]                   has_future <- base::requireNamespace("future", 
  [07:16:40.827]                     quietly = TRUE)
  [07:16:40.827]                   version <- if (has_future) 
  [07:16:40.827]                     utils::packageVersion("future")
  [07:16:40.827]                   else NULL
  [07:16:40.827]                   if (!has_future || version < "1.8.0") {
  [07:16:40.827]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.827]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.827]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.827]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.827]                         "release", "version")], collapse = " "), 
  [07:16:40.827]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.827]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.827]                       info)
  [07:16:40.827]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.827]                     if (!has_future) {
  [07:16:40.827]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.827]                         info)
  [07:16:40.827]                     }
  [07:16:40.827]                     else {
  [07:16:40.827]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.827]                         info, version)
  [07:16:40.827]                     }
  [07:16:40.827]                     base::stop(msg)
  [07:16:40.827]                   }
  [07:16:40.827]                 })
  [07:16:40.827]             }
  [07:16:40.827]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.827]         }
  [07:16:40.827]     }
  [07:16:40.827]     if (base::is.na(NA)) {
  [07:16:40.827]     }
  [07:16:40.827]     else {
  [07:16:40.827]         if (NA) {
  [07:16:40.827]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.827]                 open = "w")
  [07:16:40.827]         }
  [07:16:40.827]         else {
  [07:16:40.827]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.827]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.827]         }
  [07:16:40.827]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.827]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.827]             base::sink(type = "output", split = FALSE)
  [07:16:40.827]             base::close(...future.stdout)
  [07:16:40.827]         }, add = TRUE)
  [07:16:40.827]     }
  [07:16:40.827]     ...future.frame <- base::sys.nframe()
  [07:16:40.827]     ...future.conditions <- base::list()
  [07:16:40.827]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.827]     ...future.result <- base::tryCatch({
  [07:16:40.827]         base::withCallingHandlers({
  [07:16:40.827]             ...future.value <- base::withVisible(base::local({
  [07:16:40.827]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.827]             }))
  [07:16:40.827]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.827]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.827]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.827]                 version = "1.8")
  [07:16:40.827]         }, condition = base::local({
  [07:16:40.827]             c <- base::c
  [07:16:40.827]             inherits <- base::inherits
  [07:16:40.827]             invokeRestart <- base::invokeRestart
  [07:16:40.827]             length <- base::length
  [07:16:40.827]             list <- base::list
  [07:16:40.827]             seq.int <- base::seq.int
  [07:16:40.827]             signalCondition <- base::signalCondition
  [07:16:40.827]             sys.calls <- base::sys.calls
  [07:16:40.827]             Sys.time <- base::Sys.time
  [07:16:40.827]             `[[` <- base::`[[`
  [07:16:40.827]             `+` <- base::`+`
  [07:16:40.827]             `<<-` <- base::`<<-`
  [07:16:40.827]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.827]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.827]                   3L)]
  [07:16:40.827]             }
  [07:16:40.827]             function(cond) {
  [07:16:40.827]                 if (inherits(cond, "error")) {
  [07:16:40.827]                   sessionInformation <- function() {
  [07:16:40.827]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.827]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.827]                       search = base::search(), system = base::Sys.info())
  [07:16:40.827]                   }
  [07:16:40.827]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.827]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.827]                     cond$call), session = sessionInformation(), 
  [07:16:40.827]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.827]                   signalCondition(cond)
  [07:16:40.827]                 }
  [07:16:40.827]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.827]                 ))) {
  [07:16:40.827]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.827]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.827]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.827]                   if (!signal) {
  [07:16:40.827]                     muffleCondition <- function (cond) 
  [07:16:40.827]                     {
  [07:16:40.827]                       inherits <- base::inherits
  [07:16:40.827]                       invokeRestart <- base::invokeRestart
  [07:16:40.827]                       muffled <- FALSE
  [07:16:40.827]                       if (inherits(cond, "message")) {
  [07:16:40.827]                         invokeRestart("muffleMessage")
  [07:16:40.827]                         muffled <- TRUE
  [07:16:40.827]                       }
  [07:16:40.827]                       else if (inherits(cond, "warning")) {
  [07:16:40.827]                         invokeRestart("muffleWarning")
  [07:16:40.827]                         muffled <- TRUE
  [07:16:40.827]                       }
  [07:16:40.827]                       else if (inherits(cond, "condition")) {
  [07:16:40.827]                         computeRestarts <- base::computeRestarts
  [07:16:40.827]                         grepl <- base::grepl
  [07:16:40.827]                         is.null <- base::is.null
  [07:16:40.827]                         restarts <- computeRestarts(cond)
  [07:16:40.827]                         for (restart in restarts) {
  [07:16:40.827]                           name <- restart$name
  [07:16:40.827]                           if (is.null(name)) 
  [07:16:40.827]                             next
  [07:16:40.827]                           if (!grepl("^muffle", name)) 
  [07:16:40.827]                             next
  [07:16:40.827]                           invokeRestart(restart)
  [07:16:40.827]                           muffled <- TRUE
  [07:16:40.827]                           break
  [07:16:40.827]                         }
  [07:16:40.827]                       }
  [07:16:40.827]                       invisible(muffled)
  [07:16:40.827]                     }
  [07:16:40.827]                     muffleCondition(cond)
  [07:16:40.827]                   }
  [07:16:40.827]                 }
  [07:16:40.827]             }
  [07:16:40.827]         }))
  [07:16:40.827]     }, error = function(ex) {
  [07:16:40.827]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.827]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.827]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.827]     }, finally = {
  [07:16:40.827]         {
  [07:16:40.827]             NULL
  [07:16:40.827]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.827]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.827]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.827]                 label = NULL, ...) 
  [07:16:40.827]             {
  [07:16:40.827]                 if (substitute) 
  [07:16:40.827]                   expr <- substitute(expr)
  [07:16:40.827]                 local <- as.logical(local)
  [07:16:40.827]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.827]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.827]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.827]                   label = label, ...)
  [07:16:40.827]                 if (!future$lazy) 
  [07:16:40.827]                   future <- run(future)
  [07:16:40.827]                 invisible(future)
  [07:16:40.827]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.827]         }
  [07:16:40.827]         base::options(...future.oldOptions)
  [07:16:40.827]     })
  [07:16:40.827]     Sys.time
  [07:16:40.827]     if (base::is.na(NA)) {
  [07:16:40.827]     }
  [07:16:40.827]     else {
  [07:16:40.827]         base::sink(type = "output", split = FALSE)
  [07:16:40.827]         if (NA) {
  [07:16:40.827]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.827]         }
  [07:16:40.827]         else {
  [07:16:40.827]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.827]         }
  [07:16:40.827]         base::close(...future.stdout)
  [07:16:40.827]         ...future.stdout <- NULL
  [07:16:40.827]     }
  [07:16:40.827]     ...future.result$conditions <- ...future.conditions
  [07:16:40.827]     ...future.result
  [07:16:40.827] }
  [07:16:40.830] plan(): Setting new future strategy stack:
  [07:16:40.830] List of future strategies:
  [07:16:40.830] 1. sequential:
  [07:16:40.830]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.830]    - tweaked: FALSE
  [07:16:40.830]    - call: NULL
  [07:16:40.831] plan(): nbrOfWorkers() = 1
  [07:16:40.833] Packages needed by the future expression (n = 0): <none>
  [07:16:40.833] Packages needed by future strategies (n = 0): <none>
  [07:16:40.836] {
  [07:16:40.836]     {
  [07:16:40.836]         ...future.startTime <- base::Sys.time()
  [07:16:40.836]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.836]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.836]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.836]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.836]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.836]         {
  [07:16:40.836]             {
  [07:16:40.836]                 base::local({
  [07:16:40.836]                   has_future <- base::requireNamespace("future", 
  [07:16:40.836]                     quietly = TRUE)
  [07:16:40.836]                   version <- if (has_future) 
  [07:16:40.836]                     utils::packageVersion("future")
  [07:16:40.836]                   else NULL
  [07:16:40.836]                   if (!has_future || version < "1.8.0") {
  [07:16:40.836]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.836]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.836]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.836]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.836]                         "release", "version")], collapse = " "), 
  [07:16:40.836]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.836]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.836]                       info)
  [07:16:40.836]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.836]                     if (!has_future) {
  [07:16:40.836]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.836]                         info)
  [07:16:40.836]                     }
  [07:16:40.836]                     else {
  [07:16:40.836]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.836]                         info, version)
  [07:16:40.836]                     }
  [07:16:40.836]                     base::stop(msg)
  [07:16:40.836]                   }
  [07:16:40.836]                 })
  [07:16:40.836]             }
  [07:16:40.836]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.836]         }
  [07:16:40.836]     }
  [07:16:40.836]     if (base::is.na(NA)) {
  [07:16:40.836]     }
  [07:16:40.836]     else {
  [07:16:40.836]         if (NA) {
  [07:16:40.836]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.836]                 open = "w")
  [07:16:40.836]         }
  [07:16:40.836]         else {
  [07:16:40.836]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.836]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.836]         }
  [07:16:40.836]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.836]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.836]             base::sink(type = "output", split = FALSE)
  [07:16:40.836]             base::close(...future.stdout)
  [07:16:40.836]         }, add = TRUE)
  [07:16:40.836]     }
  [07:16:40.836]     ...future.frame <- base::sys.nframe()
  [07:16:40.836]     ...future.conditions <- base::list()
  [07:16:40.836]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.836]     ...future.result <- base::tryCatch({
  [07:16:40.836]         base::withCallingHandlers({
  [07:16:40.836]             ...future.value <- base::withVisible(base::local({
  [07:16:40.836]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.836]             }))
  [07:16:40.836]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.836]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.836]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.836]                 version = "1.8")
  [07:16:40.836]         }, condition = base::local({
  [07:16:40.836]             c <- base::c
  [07:16:40.836]             inherits <- base::inherits
  [07:16:40.836]             invokeRestart <- base::invokeRestart
  [07:16:40.836]             length <- base::length
  [07:16:40.836]             list <- base::list
  [07:16:40.836]             seq.int <- base::seq.int
  [07:16:40.836]             signalCondition <- base::signalCondition
  [07:16:40.836]             sys.calls <- base::sys.calls
  [07:16:40.836]             Sys.time <- base::Sys.time
  [07:16:40.836]             `[[` <- base::`[[`
  [07:16:40.836]             `+` <- base::`+`
  [07:16:40.836]             `<<-` <- base::`<<-`
  [07:16:40.836]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.836]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.836]                   3L)]
  [07:16:40.836]             }
  [07:16:40.836]             function(cond) {
  [07:16:40.836]                 if (inherits(cond, "error")) {
  [07:16:40.836]                   sessionInformation <- function() {
  [07:16:40.836]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.836]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.836]                       search = base::search(), system = base::Sys.info())
  [07:16:40.836]                   }
  [07:16:40.836]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.836]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.836]                     cond$call), session = sessionInformation(), 
  [07:16:40.836]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.836]                   signalCondition(cond)
  [07:16:40.836]                 }
  [07:16:40.836]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.836]                 ))) {
  [07:16:40.836]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.836]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.836]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.836]                   if (!signal) {
  [07:16:40.836]                     muffleCondition <- function (cond) 
  [07:16:40.836]                     {
  [07:16:40.836]                       inherits <- base::inherits
  [07:16:40.836]                       invokeRestart <- base::invokeRestart
  [07:16:40.836]                       muffled <- FALSE
  [07:16:40.836]                       if (inherits(cond, "message")) {
  [07:16:40.836]                         invokeRestart("muffleMessage")
  [07:16:40.836]                         muffled <- TRUE
  [07:16:40.836]                       }
  [07:16:40.836]                       else if (inherits(cond, "warning")) {
  [07:16:40.836]                         invokeRestart("muffleWarning")
  [07:16:40.836]                         muffled <- TRUE
  [07:16:40.836]                       }
  [07:16:40.836]                       else if (inherits(cond, "condition")) {
  [07:16:40.836]                         computeRestarts <- base::computeRestarts
  [07:16:40.836]                         grepl <- base::grepl
  [07:16:40.836]                         is.null <- base::is.null
  [07:16:40.836]                         restarts <- computeRestarts(cond)
  [07:16:40.836]                         for (restart in restarts) {
  [07:16:40.836]                           name <- restart$name
  [07:16:40.836]                           if (is.null(name)) 
  [07:16:40.836]                             next
  [07:16:40.836]                           if (!grepl("^muffle", name)) 
  [07:16:40.836]                             next
  [07:16:40.836]                           invokeRestart(restart)
  [07:16:40.836]                           muffled <- TRUE
  [07:16:40.836]                           break
  [07:16:40.836]                         }
  [07:16:40.836]                       }
  [07:16:40.836]                       invisible(muffled)
  [07:16:40.836]                     }
  [07:16:40.836]                     muffleCondition(cond)
  [07:16:40.836]                   }
  [07:16:40.836]                 }
  [07:16:40.836]             }
  [07:16:40.836]         }))
  [07:16:40.836]     }, error = function(ex) {
  [07:16:40.836]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.836]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.836]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.836]     }, finally = {
  [07:16:40.836]         {
  [07:16:40.836]             NULL
  [07:16:40.836]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.836]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.836]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.836]                 label = NULL, ...) 
  [07:16:40.836]             {
  [07:16:40.836]                 if (substitute) 
  [07:16:40.836]                   expr <- substitute(expr)
  [07:16:40.836]                 local <- as.logical(local)
  [07:16:40.836]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.836]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.836]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.836]                   label = label, ...)
  [07:16:40.836]                 if (!future$lazy) 
  [07:16:40.836]                   future <- run(future)
  [07:16:40.836]                 invisible(future)
  [07:16:40.836]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.836]         }
  [07:16:40.836]         base::options(...future.oldOptions)
  [07:16:40.836]     })
  [07:16:40.836]     Sys.time
  [07:16:40.836]     if (base::is.na(NA)) {
  [07:16:40.836]     }
  [07:16:40.836]     else {
  [07:16:40.836]         base::sink(type = "output", split = FALSE)
  [07:16:40.836]         if (NA) {
  [07:16:40.836]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.836]         }
  [07:16:40.836]         else {
  [07:16:40.836]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.836]         }
  [07:16:40.836]         base::close(...future.stdout)
  [07:16:40.836]         ...future.stdout <- NULL
  [07:16:40.836]     }
  [07:16:40.836]     ...future.result$conditions <- ...future.conditions
  [07:16:40.836]     ...future.result
  [07:16:40.836] }
  [07:16:40.840] plan(): Setting new future strategy stack:
  [07:16:40.840] List of future strategies:
  [07:16:40.840] 1. sequential:
  [07:16:40.840]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.840]    - tweaked: FALSE
  [07:16:40.840]    - call: NULL
  [07:16:40.841] plan(): nbrOfWorkers() = 1
  [07:16:40.842] Packages needed by the future expression (n = 0): <none>
  [07:16:40.843] Packages needed by future strategies (n = 0): <none>
  [07:16:40.846] {
  [07:16:40.846]     {
  [07:16:40.846]         ...future.startTime <- base::Sys.time()
  [07:16:40.846]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.846]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.846]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.846]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.846]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.846]         {
  [07:16:40.846]             {
  [07:16:40.846]                 base::local({
  [07:16:40.846]                   has_future <- base::requireNamespace("future", 
  [07:16:40.846]                     quietly = TRUE)
  [07:16:40.846]                   version <- if (has_future) 
  [07:16:40.846]                     utils::packageVersion("future")
  [07:16:40.846]                   else NULL
  [07:16:40.846]                   if (!has_future || version < "1.8.0") {
  [07:16:40.846]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.846]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.846]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.846]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.846]                         "release", "version")], collapse = " "), 
  [07:16:40.846]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.846]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.846]                       info)
  [07:16:40.846]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.846]                     if (!has_future) {
  [07:16:40.846]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.846]                         info)
  [07:16:40.846]                     }
  [07:16:40.846]                     else {
  [07:16:40.846]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.846]                         info, version)
  [07:16:40.846]                     }
  [07:16:40.846]                     base::stop(msg)
  [07:16:40.846]                   }
  [07:16:40.846]                 })
  [07:16:40.846]             }
  [07:16:40.846]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.846]         }
  [07:16:40.846]     }
  [07:16:40.846]     if (base::is.na(NA)) {
  [07:16:40.846]     }
  [07:16:40.846]     else {
  [07:16:40.846]         if (NA) {
  [07:16:40.846]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.846]                 open = "w")
  [07:16:40.846]         }
  [07:16:40.846]         else {
  [07:16:40.846]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.846]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.846]         }
  [07:16:40.846]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.846]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.846]             base::sink(type = "output", split = FALSE)
  [07:16:40.846]             base::close(...future.stdout)
  [07:16:40.846]         }, add = TRUE)
  [07:16:40.846]     }
  [07:16:40.846]     ...future.frame <- base::sys.nframe()
  [07:16:40.846]     ...future.conditions <- base::list()
  [07:16:40.846]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.846]     ...future.result <- base::tryCatch({
  [07:16:40.846]         base::withCallingHandlers({
  [07:16:40.846]             ...future.value <- base::withVisible(base::local({
  [07:16:40.846]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.846]             }))
  [07:16:40.846]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.846]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.846]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.846]                 version = "1.8")
  [07:16:40.846]         }, condition = base::local({
  [07:16:40.846]             c <- base::c
  [07:16:40.846]             inherits <- base::inherits
  [07:16:40.846]             invokeRestart <- base::invokeRestart
  [07:16:40.846]             length <- base::length
  [07:16:40.846]             list <- base::list
  [07:16:40.846]             seq.int <- base::seq.int
  [07:16:40.846]             signalCondition <- base::signalCondition
  [07:16:40.846]             sys.calls <- base::sys.calls
  [07:16:40.846]             Sys.time <- base::Sys.time
  [07:16:40.846]             `[[` <- base::`[[`
  [07:16:40.846]             `+` <- base::`+`
  [07:16:40.846]             `<<-` <- base::`<<-`
  [07:16:40.846]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.846]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.846]                   3L)]
  [07:16:40.846]             }
  [07:16:40.846]             function(cond) {
  [07:16:40.846]                 if (inherits(cond, "error")) {
  [07:16:40.846]                   sessionInformation <- function() {
  [07:16:40.846]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.846]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.846]                       search = base::search(), system = base::Sys.info())
  [07:16:40.846]                   }
  [07:16:40.846]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.846]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.846]                     cond$call), session = sessionInformation(), 
  [07:16:40.846]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.846]                   signalCondition(cond)
  [07:16:40.846]                 }
  [07:16:40.846]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.846]                 ))) {
  [07:16:40.846]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.846]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.846]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.846]                   if (!signal) {
  [07:16:40.846]                     muffleCondition <- function (cond) 
  [07:16:40.846]                     {
  [07:16:40.846]                       inherits <- base::inherits
  [07:16:40.846]                       invokeRestart <- base::invokeRestart
  [07:16:40.846]                       muffled <- FALSE
  [07:16:40.846]                       if (inherits(cond, "message")) {
  [07:16:40.846]                         invokeRestart("muffleMessage")
  [07:16:40.846]                         muffled <- TRUE
  [07:16:40.846]                       }
  [07:16:40.846]                       else if (inherits(cond, "warning")) {
  [07:16:40.846]                         invokeRestart("muffleWarning")
  [07:16:40.846]                         muffled <- TRUE
  [07:16:40.846]                       }
  [07:16:40.846]                       else if (inherits(cond, "condition")) {
  [07:16:40.846]                         computeRestarts <- base::computeRestarts
  [07:16:40.846]                         grepl <- base::grepl
  [07:16:40.846]                         is.null <- base::is.null
  [07:16:40.846]                         restarts <- computeRestarts(cond)
  [07:16:40.846]                         for (restart in restarts) {
  [07:16:40.846]                           name <- restart$name
  [07:16:40.846]                           if (is.null(name)) 
  [07:16:40.846]                             next
  [07:16:40.846]                           if (!grepl("^muffle", name)) 
  [07:16:40.846]                             next
  [07:16:40.846]                           invokeRestart(restart)
  [07:16:40.846]                           muffled <- TRUE
  [07:16:40.846]                           break
  [07:16:40.846]                         }
  [07:16:40.846]                       }
  [07:16:40.846]                       invisible(muffled)
  [07:16:40.846]                     }
  [07:16:40.846]                     muffleCondition(cond)
  [07:16:40.846]                   }
  [07:16:40.846]                 }
  [07:16:40.846]             }
  [07:16:40.846]         }))
  [07:16:40.846]     }, error = function(ex) {
  [07:16:40.846]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.846]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.846]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.846]     }, finally = {
  [07:16:40.846]         {
  [07:16:40.846]             NULL
  [07:16:40.846]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.846]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.846]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.846]                 label = NULL, ...) 
  [07:16:40.846]             {
  [07:16:40.846]                 if (substitute) 
  [07:16:40.846]                   expr <- substitute(expr)
  [07:16:40.846]                 local <- as.logical(local)
  [07:16:40.846]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.846]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.846]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.846]                   label = label, ...)
  [07:16:40.846]                 if (!future$lazy) 
  [07:16:40.846]                   future <- run(future)
  [07:16:40.846]                 invisible(future)
  [07:16:40.846]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.846]         }
  [07:16:40.846]         base::options(...future.oldOptions)
  [07:16:40.846]     })
  [07:16:40.846]     Sys.time
  [07:16:40.846]     if (base::is.na(NA)) {
  [07:16:40.846]     }
  [07:16:40.846]     else {
  [07:16:40.846]         base::sink(type = "output", split = FALSE)
  [07:16:40.846]         if (NA) {
  [07:16:40.846]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.846]         }
  [07:16:40.846]         else {
  [07:16:40.846]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.846]         }
  [07:16:40.846]         base::close(...future.stdout)
  [07:16:40.846]         ...future.stdout <- NULL
  [07:16:40.846]     }
  [07:16:40.846]     ...future.result$conditions <- ...future.conditions
  [07:16:40.846]     ...future.result
  [07:16:40.846] }
  [07:16:40.849] plan(): Setting new future strategy stack:
  [07:16:40.850] List of future strategies:
  [07:16:40.850] 1. sequential:
  [07:16:40.850]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.850]    - tweaked: FALSE
  [07:16:40.850]    - call: NULL
  [07:16:40.851] plan(): nbrOfWorkers() = 1
  [07:16:40.852] Packages needed by the future expression (n = 0): <none>
  [07:16:40.853] Packages needed by future strategies (n = 0): <none>
  [07:16:40.856] {
  [07:16:40.856]     {
  [07:16:40.856]         ...future.startTime <- base::Sys.time()
  [07:16:40.856]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.856]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.856]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.856]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.856]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.856]         {
  [07:16:40.856]             {
  [07:16:40.856]                 base::local({
  [07:16:40.856]                   has_future <- base::requireNamespace("future", 
  [07:16:40.856]                     quietly = TRUE)
  [07:16:40.856]                   version <- if (has_future) 
  [07:16:40.856]                     utils::packageVersion("future")
  [07:16:40.856]                   else NULL
  [07:16:40.856]                   if (!has_future || version < "1.8.0") {
  [07:16:40.856]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.856]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.856]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.856]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.856]                         "release", "version")], collapse = " "), 
  [07:16:40.856]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.856]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.856]                       info)
  [07:16:40.856]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.856]                     if (!has_future) {
  [07:16:40.856]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.856]                         info)
  [07:16:40.856]                     }
  [07:16:40.856]                     else {
  [07:16:40.856]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.856]                         info, version)
  [07:16:40.856]                     }
  [07:16:40.856]                     base::stop(msg)
  [07:16:40.856]                   }
  [07:16:40.856]                 })
  [07:16:40.856]             }
  [07:16:40.856]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.856]         }
  [07:16:40.856]     }
  [07:16:40.856]     if (base::is.na(NA)) {
  [07:16:40.856]     }
  [07:16:40.856]     else {
  [07:16:40.856]         if (NA) {
  [07:16:40.856]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.856]                 open = "w")
  [07:16:40.856]         }
  [07:16:40.856]         else {
  [07:16:40.856]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.856]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.856]         }
  [07:16:40.856]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.856]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.856]             base::sink(type = "output", split = FALSE)
  [07:16:40.856]             base::close(...future.stdout)
  [07:16:40.856]         }, add = TRUE)
  [07:16:40.856]     }
  [07:16:40.856]     ...future.frame <- base::sys.nframe()
  [07:16:40.856]     ...future.conditions <- base::list()
  [07:16:40.856]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.856]     ...future.result <- base::tryCatch({
  [07:16:40.856]         base::withCallingHandlers({
  [07:16:40.856]             ...future.value <- base::withVisible(base::local({
  [07:16:40.856]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.856]             }))
  [07:16:40.856]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.856]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.856]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.856]                 version = "1.8")
  [07:16:40.856]         }, condition = base::local({
  [07:16:40.856]             c <- base::c
  [07:16:40.856]             inherits <- base::inherits
  [07:16:40.856]             invokeRestart <- base::invokeRestart
  [07:16:40.856]             length <- base::length
  [07:16:40.856]             list <- base::list
  [07:16:40.856]             seq.int <- base::seq.int
  [07:16:40.856]             signalCondition <- base::signalCondition
  [07:16:40.856]             sys.calls <- base::sys.calls
  [07:16:40.856]             Sys.time <- base::Sys.time
  [07:16:40.856]             `[[` <- base::`[[`
  [07:16:40.856]             `+` <- base::`+`
  [07:16:40.856]             `<<-` <- base::`<<-`
  [07:16:40.856]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.856]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.856]                   3L)]
  [07:16:40.856]             }
  [07:16:40.856]             function(cond) {
  [07:16:40.856]                 if (inherits(cond, "error")) {
  [07:16:40.856]                   sessionInformation <- function() {
  [07:16:40.856]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.856]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.856]                       search = base::search(), system = base::Sys.info())
  [07:16:40.856]                   }
  [07:16:40.856]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.856]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.856]                     cond$call), session = sessionInformation(), 
  [07:16:40.856]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.856]                   signalCondition(cond)
  [07:16:40.856]                 }
  [07:16:40.856]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.856]                 ))) {
  [07:16:40.856]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.856]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.856]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.856]                   if (!signal) {
  [07:16:40.856]                     muffleCondition <- function (cond) 
  [07:16:40.856]                     {
  [07:16:40.856]                       inherits <- base::inherits
  [07:16:40.856]                       invokeRestart <- base::invokeRestart
  [07:16:40.856]                       muffled <- FALSE
  [07:16:40.856]                       if (inherits(cond, "message")) {
  [07:16:40.856]                         invokeRestart("muffleMessage")
  [07:16:40.856]                         muffled <- TRUE
  [07:16:40.856]                       }
  [07:16:40.856]                       else if (inherits(cond, "warning")) {
  [07:16:40.856]                         invokeRestart("muffleWarning")
  [07:16:40.856]                         muffled <- TRUE
  [07:16:40.856]                       }
  [07:16:40.856]                       else if (inherits(cond, "condition")) {
  [07:16:40.856]                         computeRestarts <- base::computeRestarts
  [07:16:40.856]                         grepl <- base::grepl
  [07:16:40.856]                         is.null <- base::is.null
  [07:16:40.856]                         restarts <- computeRestarts(cond)
  [07:16:40.856]                         for (restart in restarts) {
  [07:16:40.856]                           name <- restart$name
  [07:16:40.856]                           if (is.null(name)) 
  [07:16:40.856]                             next
  [07:16:40.856]                           if (!grepl("^muffle", name)) 
  [07:16:40.856]                             next
  [07:16:40.856]                           invokeRestart(restart)
  [07:16:40.856]                           muffled <- TRUE
  [07:16:40.856]                           break
  [07:16:40.856]                         }
  [07:16:40.856]                       }
  [07:16:40.856]                       invisible(muffled)
  [07:16:40.856]                     }
  [07:16:40.856]                     muffleCondition(cond)
  [07:16:40.856]                   }
  [07:16:40.856]                 }
  [07:16:40.856]             }
  [07:16:40.856]         }))
  [07:16:40.856]     }, error = function(ex) {
  [07:16:40.856]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.856]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.856]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.856]     }, finally = {
  [07:16:40.856]         {
  [07:16:40.856]             NULL
  [07:16:40.856]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.856]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.856]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.856]                 label = NULL, ...) 
  [07:16:40.856]             {
  [07:16:40.856]                 if (substitute) 
  [07:16:40.856]                   expr <- substitute(expr)
  [07:16:40.856]                 local <- as.logical(local)
  [07:16:40.856]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.856]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.856]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.856]                   label = label, ...)
  [07:16:40.856]                 if (!future$lazy) 
  [07:16:40.856]                   future <- run(future)
  [07:16:40.856]                 invisible(future)
  [07:16:40.856]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.856]         }
  [07:16:40.856]         base::options(...future.oldOptions)
  [07:16:40.856]     })
  [07:16:40.856]     Sys.time
  [07:16:40.856]     if (base::is.na(NA)) {
  [07:16:40.856]     }
  [07:16:40.856]     else {
  [07:16:40.856]         base::sink(type = "output", split = FALSE)
  [07:16:40.856]         if (NA) {
  [07:16:40.856]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.856]         }
  [07:16:40.856]         else {
  [07:16:40.856]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.856]         }
  [07:16:40.856]         base::close(...future.stdout)
  [07:16:40.856]         ...future.stdout <- NULL
  [07:16:40.856]     }
  [07:16:40.856]     ...future.result$conditions <- ...future.conditions
  [07:16:40.856]     ...future.result
  [07:16:40.856] }
  [07:16:40.860] plan(): Setting new future strategy stack:
  [07:16:40.860] List of future strategies:
  [07:16:40.860] 1. sequential:
  [07:16:40.860]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.860]    - tweaked: FALSE
  [07:16:40.860]    - call: NULL
  [07:16:40.861] plan(): nbrOfWorkers() = 1
  [07:16:40.863] Packages needed by the future expression (n = 0): <none>
  [07:16:40.863] Packages needed by future strategies (n = 0): <none>
  [07:16:40.869] {
  [07:16:40.869]     {
  [07:16:40.869]         ...future.startTime <- base::Sys.time()
  [07:16:40.869]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.869]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.869]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.869]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.869]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.869]         {
  [07:16:40.869]             {
  [07:16:40.869]                 base::local({
  [07:16:40.869]                   has_future <- base::requireNamespace("future", 
  [07:16:40.869]                     quietly = TRUE)
  [07:16:40.869]                   version <- if (has_future) 
  [07:16:40.869]                     utils::packageVersion("future")
  [07:16:40.869]                   else NULL
  [07:16:40.869]                   if (!has_future || version < "1.8.0") {
  [07:16:40.869]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.869]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.869]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.869]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.869]                         "release", "version")], collapse = " "), 
  [07:16:40.869]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.869]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.869]                       info)
  [07:16:40.869]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.869]                     if (!has_future) {
  [07:16:40.869]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.869]                         info)
  [07:16:40.869]                     }
  [07:16:40.869]                     else {
  [07:16:40.869]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.869]                         info, version)
  [07:16:40.869]                     }
  [07:16:40.869]                     base::stop(msg)
  [07:16:40.869]                   }
  [07:16:40.869]                 })
  [07:16:40.869]             }
  [07:16:40.869]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.869]         }
  [07:16:40.869]     }
  [07:16:40.869]     if (base::is.na(NA)) {
  [07:16:40.869]     }
  [07:16:40.869]     else {
  [07:16:40.869]         if (NA) {
  [07:16:40.869]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.869]                 open = "w")
  [07:16:40.869]         }
  [07:16:40.869]         else {
  [07:16:40.869]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.869]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.869]         }
  [07:16:40.869]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.869]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.869]             base::sink(type = "output", split = FALSE)
  [07:16:40.869]             base::close(...future.stdout)
  [07:16:40.869]         }, add = TRUE)
  [07:16:40.869]     }
  [07:16:40.869]     ...future.frame <- base::sys.nframe()
  [07:16:40.869]     ...future.conditions <- base::list()
  [07:16:40.869]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.869]     ...future.result <- base::tryCatch({
  [07:16:40.869]         base::withCallingHandlers({
  [07:16:40.869]             ...future.value <- base::withVisible(base::local({
  [07:16:40.869]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.869]             }))
  [07:16:40.869]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.869]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.869]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.869]                 version = "1.8")
  [07:16:40.869]         }, condition = base::local({
  [07:16:40.869]             c <- base::c
  [07:16:40.869]             inherits <- base::inherits
  [07:16:40.869]             invokeRestart <- base::invokeRestart
  [07:16:40.869]             length <- base::length
  [07:16:40.869]             list <- base::list
  [07:16:40.869]             seq.int <- base::seq.int
  [07:16:40.869]             signalCondition <- base::signalCondition
  [07:16:40.869]             sys.calls <- base::sys.calls
  [07:16:40.869]             Sys.time <- base::Sys.time
  [07:16:40.869]             `[[` <- base::`[[`
  [07:16:40.869]             `+` <- base::`+`
  [07:16:40.869]             `<<-` <- base::`<<-`
  [07:16:40.869]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.869]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.869]                   3L)]
  [07:16:40.869]             }
  [07:16:40.869]             function(cond) {
  [07:16:40.869]                 if (inherits(cond, "error")) {
  [07:16:40.869]                   sessionInformation <- function() {
  [07:16:40.869]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.869]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.869]                       search = base::search(), system = base::Sys.info())
  [07:16:40.869]                   }
  [07:16:40.869]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.869]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.869]                     cond$call), session = sessionInformation(), 
  [07:16:40.869]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.869]                   signalCondition(cond)
  [07:16:40.869]                 }
  [07:16:40.869]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.869]                 ))) {
  [07:16:40.869]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.869]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.869]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.869]                   if (!signal) {
  [07:16:40.869]                     muffleCondition <- function (cond) 
  [07:16:40.869]                     {
  [07:16:40.869]                       inherits <- base::inherits
  [07:16:40.869]                       invokeRestart <- base::invokeRestart
  [07:16:40.869]                       muffled <- FALSE
  [07:16:40.869]                       if (inherits(cond, "message")) {
  [07:16:40.869]                         invokeRestart("muffleMessage")
  [07:16:40.869]                         muffled <- TRUE
  [07:16:40.869]                       }
  [07:16:40.869]                       else if (inherits(cond, "warning")) {
  [07:16:40.869]                         invokeRestart("muffleWarning")
  [07:16:40.869]                         muffled <- TRUE
  [07:16:40.869]                       }
  [07:16:40.869]                       else if (inherits(cond, "condition")) {
  [07:16:40.869]                         computeRestarts <- base::computeRestarts
  [07:16:40.869]                         grepl <- base::grepl
  [07:16:40.869]                         is.null <- base::is.null
  [07:16:40.869]                         restarts <- computeRestarts(cond)
  [07:16:40.869]                         for (restart in restarts) {
  [07:16:40.869]                           name <- restart$name
  [07:16:40.869]                           if (is.null(name)) 
  [07:16:40.869]                             next
  [07:16:40.869]                           if (!grepl("^muffle", name)) 
  [07:16:40.869]                             next
  [07:16:40.869]                           invokeRestart(restart)
  [07:16:40.869]                           muffled <- TRUE
  [07:16:40.869]                           break
  [07:16:40.869]                         }
  [07:16:40.869]                       }
  [07:16:40.869]                       invisible(muffled)
  [07:16:40.869]                     }
  [07:16:40.869]                     muffleCondition(cond)
  [07:16:40.869]                   }
  [07:16:40.869]                 }
  [07:16:40.869]             }
  [07:16:40.869]         }))
  [07:16:40.869]     }, error = function(ex) {
  [07:16:40.869]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.869]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.869]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.869]     }, finally = {
  [07:16:40.869]         {
  [07:16:40.869]             NULL
  [07:16:40.869]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.869]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.869]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.869]                 label = NULL, ...) 
  [07:16:40.869]             {
  [07:16:40.869]                 if (substitute) 
  [07:16:40.869]                   expr <- substitute(expr)
  [07:16:40.869]                 local <- as.logical(local)
  [07:16:40.869]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.869]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.869]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.869]                   label = label, ...)
  [07:16:40.869]                 if (!future$lazy) 
  [07:16:40.869]                   future <- run(future)
  [07:16:40.869]                 invisible(future)
  [07:16:40.869]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.869]         }
  [07:16:40.869]         base::options(...future.oldOptions)
  [07:16:40.869]     })
  [07:16:40.869]     Sys.time
  [07:16:40.869]     if (base::is.na(NA)) {
  [07:16:40.869]     }
  [07:16:40.869]     else {
  [07:16:40.869]         base::sink(type = "output", split = FALSE)
  [07:16:40.869]         if (NA) {
  [07:16:40.869]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.869]         }
  [07:16:40.869]         else {
  [07:16:40.869]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.869]         }
  [07:16:40.869]         base::close(...future.stdout)
  [07:16:40.869]         ...future.stdout <- NULL
  [07:16:40.869]     }
  [07:16:40.869]     ...future.result$conditions <- ...future.conditions
  [07:16:40.869]     ...future.result
  [07:16:40.869] }
  [07:16:40.873] plan(): Setting new future strategy stack:
  [07:16:40.873] List of future strategies:
  [07:16:40.873] 1. sequential:
  [07:16:40.873]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.873]    - tweaked: FALSE
  [07:16:40.873]    - call: NULL
  [07:16:40.874] plan(): nbrOfWorkers() = 1
  [07:16:40.876] Packages needed by the future expression (n = 0): <none>
  [07:16:40.877] Packages needed by future strategies (n = 0): <none>
  [07:16:40.880] {
  [07:16:40.880]     {
  [07:16:40.880]         ...future.startTime <- base::Sys.time()
  [07:16:40.880]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.880]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.880]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.880]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.880]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.880]         {
  [07:16:40.880]             {
  [07:16:40.880]                 base::local({
  [07:16:40.880]                   has_future <- base::requireNamespace("future", 
  [07:16:40.880]                     quietly = TRUE)
  [07:16:40.880]                   version <- if (has_future) 
  [07:16:40.880]                     utils::packageVersion("future")
  [07:16:40.880]                   else NULL
  [07:16:40.880]                   if (!has_future || version < "1.8.0") {
  [07:16:40.880]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.880]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.880]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.880]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.880]                         "release", "version")], collapse = " "), 
  [07:16:40.880]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.880]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.880]                       info)
  [07:16:40.880]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.880]                     if (!has_future) {
  [07:16:40.880]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.880]                         info)
  [07:16:40.880]                     }
  [07:16:40.880]                     else {
  [07:16:40.880]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.880]                         info, version)
  [07:16:40.880]                     }
  [07:16:40.880]                     base::stop(msg)
  [07:16:40.880]                   }
  [07:16:40.880]                 })
  [07:16:40.880]             }
  [07:16:40.880]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.880]         }
  [07:16:40.880]     }
  [07:16:40.880]     if (base::is.na(NA)) {
  [07:16:40.880]     }
  [07:16:40.880]     else {
  [07:16:40.880]         if (NA) {
  [07:16:40.880]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.880]                 open = "w")
  [07:16:40.880]         }
  [07:16:40.880]         else {
  [07:16:40.880]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.880]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.880]         }
  [07:16:40.880]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.880]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.880]             base::sink(type = "output", split = FALSE)
  [07:16:40.880]             base::close(...future.stdout)
  [07:16:40.880]         }, add = TRUE)
  [07:16:40.880]     }
  [07:16:40.880]     ...future.frame <- base::sys.nframe()
  [07:16:40.880]     ...future.conditions <- base::list()
  [07:16:40.880]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.880]     ...future.result <- base::tryCatch({
  [07:16:40.880]         base::withCallingHandlers({
  [07:16:40.880]             ...future.value <- base::withVisible(base::local({
  [07:16:40.880]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.880]             }))
  [07:16:40.880]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.880]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.880]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.880]                 version = "1.8")
  [07:16:40.880]         }, condition = base::local({
  [07:16:40.880]             c <- base::c
  [07:16:40.880]             inherits <- base::inherits
  [07:16:40.880]             invokeRestart <- base::invokeRestart
  [07:16:40.880]             length <- base::length
  [07:16:40.880]             list <- base::list
  [07:16:40.880]             seq.int <- base::seq.int
  [07:16:40.880]             signalCondition <- base::signalCondition
  [07:16:40.880]             sys.calls <- base::sys.calls
  [07:16:40.880]             Sys.time <- base::Sys.time
  [07:16:40.880]             `[[` <- base::`[[`
  [07:16:40.880]             `+` <- base::`+`
  [07:16:40.880]             `<<-` <- base::`<<-`
  [07:16:40.880]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.880]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.880]                   3L)]
  [07:16:40.880]             }
  [07:16:40.880]             function(cond) {
  [07:16:40.880]                 if (inherits(cond, "error")) {
  [07:16:40.880]                   sessionInformation <- function() {
  [07:16:40.880]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.880]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.880]                       search = base::search(), system = base::Sys.info())
  [07:16:40.880]                   }
  [07:16:40.880]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.880]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.880]                     cond$call), session = sessionInformation(), 
  [07:16:40.880]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.880]                   signalCondition(cond)
  [07:16:40.880]                 }
  [07:16:40.880]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.880]                 ))) {
  [07:16:40.880]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.880]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.880]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.880]                   if (!signal) {
  [07:16:40.880]                     muffleCondition <- function (cond) 
  [07:16:40.880]                     {
  [07:16:40.880]                       inherits <- base::inherits
  [07:16:40.880]                       invokeRestart <- base::invokeRestart
  [07:16:40.880]                       muffled <- FALSE
  [07:16:40.880]                       if (inherits(cond, "message")) {
  [07:16:40.880]                         invokeRestart("muffleMessage")
  [07:16:40.880]                         muffled <- TRUE
  [07:16:40.880]                       }
  [07:16:40.880]                       else if (inherits(cond, "warning")) {
  [07:16:40.880]                         invokeRestart("muffleWarning")
  [07:16:40.880]                         muffled <- TRUE
  [07:16:40.880]                       }
  [07:16:40.880]                       else if (inherits(cond, "condition")) {
  [07:16:40.880]                         computeRestarts <- base::computeRestarts
  [07:16:40.880]                         grepl <- base::grepl
  [07:16:40.880]                         is.null <- base::is.null
  [07:16:40.880]                         restarts <- computeRestarts(cond)
  [07:16:40.880]                         for (restart in restarts) {
  [07:16:40.880]                           name <- restart$name
  [07:16:40.880]                           if (is.null(name)) 
  [07:16:40.880]                             next
  [07:16:40.880]                           if (!grepl("^muffle", name)) 
  [07:16:40.880]                             next
  [07:16:40.880]                           invokeRestart(restart)
  [07:16:40.880]                           muffled <- TRUE
  [07:16:40.880]                           break
  [07:16:40.880]                         }
  [07:16:40.880]                       }
  [07:16:40.880]                       invisible(muffled)
  [07:16:40.880]                     }
  [07:16:40.880]                     muffleCondition(cond)
  [07:16:40.880]                   }
  [07:16:40.880]                 }
  [07:16:40.880]             }
  [07:16:40.880]         }))
  [07:16:40.880]     }, error = function(ex) {
  [07:16:40.880]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.880]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.880]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.880]     }, finally = {
  [07:16:40.880]         {
  [07:16:40.880]             NULL
  [07:16:40.880]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.880]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.880]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.880]                 label = NULL, ...) 
  [07:16:40.880]             {
  [07:16:40.880]                 if (substitute) 
  [07:16:40.880]                   expr <- substitute(expr)
  [07:16:40.880]                 local <- as.logical(local)
  [07:16:40.880]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.880]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.880]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.880]                   label = label, ...)
  [07:16:40.880]                 if (!future$lazy) 
  [07:16:40.880]                   future <- run(future)
  [07:16:40.880]                 invisible(future)
  [07:16:40.880]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.880]         }
  [07:16:40.880]         base::options(...future.oldOptions)
  [07:16:40.880]     })
  [07:16:40.880]     Sys.time
  [07:16:40.880]     if (base::is.na(NA)) {
  [07:16:40.880]     }
  [07:16:40.880]     else {
  [07:16:40.880]         base::sink(type = "output", split = FALSE)
  [07:16:40.880]         if (NA) {
  [07:16:40.880]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.880]         }
  [07:16:40.880]         else {
  [07:16:40.880]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.880]         }
  [07:16:40.880]         base::close(...future.stdout)
  [07:16:40.880]         ...future.stdout <- NULL
  [07:16:40.880]     }
  [07:16:40.880]     ...future.result$conditions <- ...future.conditions
  [07:16:40.880]     ...future.result
  [07:16:40.880] }
  [07:16:40.884] plan(): Setting new future strategy stack:
  [07:16:40.885] List of future strategies:
  [07:16:40.885] 1. sequential:
  [07:16:40.885]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.885]    - tweaked: FALSE
  [07:16:40.885]    - call: NULL
  [07:16:40.886] plan(): nbrOfWorkers() = 1
  [07:16:40.888] Packages needed by the future expression (n = 0): <none>
  [07:16:40.888] Packages needed by future strategies (n = 0): <none>
  [07:16:40.892] {
  [07:16:40.892]     {
  [07:16:40.892]         ...future.startTime <- base::Sys.time()
  [07:16:40.892]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.892]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.892]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.892]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.892]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.892]         {
  [07:16:40.892]             {
  [07:16:40.892]                 base::local({
  [07:16:40.892]                   has_future <- base::requireNamespace("future", 
  [07:16:40.892]                     quietly = TRUE)
  [07:16:40.892]                   version <- if (has_future) 
  [07:16:40.892]                     utils::packageVersion("future")
  [07:16:40.892]                   else NULL
  [07:16:40.892]                   if (!has_future || version < "1.8.0") {
  [07:16:40.892]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.892]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.892]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.892]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.892]                         "release", "version")], collapse = " "), 
  [07:16:40.892]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.892]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.892]                       info)
  [07:16:40.892]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.892]                     if (!has_future) {
  [07:16:40.892]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.892]                         info)
  [07:16:40.892]                     }
  [07:16:40.892]                     else {
  [07:16:40.892]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.892]                         info, version)
  [07:16:40.892]                     }
  [07:16:40.892]                     base::stop(msg)
  [07:16:40.892]                   }
  [07:16:40.892]                 })
  [07:16:40.892]             }
  [07:16:40.892]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.892]         }
  [07:16:40.892]     }
  [07:16:40.892]     if (base::is.na(NA)) {
  [07:16:40.892]     }
  [07:16:40.892]     else {
  [07:16:40.892]         if (NA) {
  [07:16:40.892]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.892]                 open = "w")
  [07:16:40.892]         }
  [07:16:40.892]         else {
  [07:16:40.892]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.892]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.892]         }
  [07:16:40.892]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.892]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.892]             base::sink(type = "output", split = FALSE)
  [07:16:40.892]             base::close(...future.stdout)
  [07:16:40.892]         }, add = TRUE)
  [07:16:40.892]     }
  [07:16:40.892]     ...future.frame <- base::sys.nframe()
  [07:16:40.892]     ...future.conditions <- base::list()
  [07:16:40.892]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.892]     ...future.result <- base::tryCatch({
  [07:16:40.892]         base::withCallingHandlers({
  [07:16:40.892]             ...future.value <- base::withVisible(base::local({
  [07:16:40.892]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.892]             }))
  [07:16:40.892]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.892]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.892]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.892]                 version = "1.8")
  [07:16:40.892]         }, condition = base::local({
  [07:16:40.892]             c <- base::c
  [07:16:40.892]             inherits <- base::inherits
  [07:16:40.892]             invokeRestart <- base::invokeRestart
  [07:16:40.892]             length <- base::length
  [07:16:40.892]             list <- base::list
  [07:16:40.892]             seq.int <- base::seq.int
  [07:16:40.892]             signalCondition <- base::signalCondition
  [07:16:40.892]             sys.calls <- base::sys.calls
  [07:16:40.892]             Sys.time <- base::Sys.time
  [07:16:40.892]             `[[` <- base::`[[`
  [07:16:40.892]             `+` <- base::`+`
  [07:16:40.892]             `<<-` <- base::`<<-`
  [07:16:40.892]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.892]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.892]                   3L)]
  [07:16:40.892]             }
  [07:16:40.892]             function(cond) {
  [07:16:40.892]                 if (inherits(cond, "error")) {
  [07:16:40.892]                   sessionInformation <- function() {
  [07:16:40.892]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.892]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.892]                       search = base::search(), system = base::Sys.info())
  [07:16:40.892]                   }
  [07:16:40.892]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.892]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.892]                     cond$call), session = sessionInformation(), 
  [07:16:40.892]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.892]                   signalCondition(cond)
  [07:16:40.892]                 }
  [07:16:40.892]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.892]                 ))) {
  [07:16:40.892]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.892]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.892]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.892]                   if (!signal) {
  [07:16:40.892]                     muffleCondition <- function (cond) 
  [07:16:40.892]                     {
  [07:16:40.892]                       inherits <- base::inherits
  [07:16:40.892]                       invokeRestart <- base::invokeRestart
  [07:16:40.892]                       muffled <- FALSE
  [07:16:40.892]                       if (inherits(cond, "message")) {
  [07:16:40.892]                         invokeRestart("muffleMessage")
  [07:16:40.892]                         muffled <- TRUE
  [07:16:40.892]                       }
  [07:16:40.892]                       else if (inherits(cond, "warning")) {
  [07:16:40.892]                         invokeRestart("muffleWarning")
  [07:16:40.892]                         muffled <- TRUE
  [07:16:40.892]                       }
  [07:16:40.892]                       else if (inherits(cond, "condition")) {
  [07:16:40.892]                         computeRestarts <- base::computeRestarts
  [07:16:40.892]                         grepl <- base::grepl
  [07:16:40.892]                         is.null <- base::is.null
  [07:16:40.892]                         restarts <- computeRestarts(cond)
  [07:16:40.892]                         for (restart in restarts) {
  [07:16:40.892]                           name <- restart$name
  [07:16:40.892]                           if (is.null(name)) 
  [07:16:40.892]                             next
  [07:16:40.892]                           if (!grepl("^muffle", name)) 
  [07:16:40.892]                             next
  [07:16:40.892]                           invokeRestart(restart)
  [07:16:40.892]                           muffled <- TRUE
  [07:16:40.892]                           break
  [07:16:40.892]                         }
  [07:16:40.892]                       }
  [07:16:40.892]                       invisible(muffled)
  [07:16:40.892]                     }
  [07:16:40.892]                     muffleCondition(cond)
  [07:16:40.892]                   }
  [07:16:40.892]                 }
  [07:16:40.892]             }
  [07:16:40.892]         }))
  [07:16:40.892]     }, error = function(ex) {
  [07:16:40.892]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.892]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.892]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.892]     }, finally = {
  [07:16:40.892]         {
  [07:16:40.892]             NULL
  [07:16:40.892]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.892]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.892]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.892]                 label = NULL, ...) 
  [07:16:40.892]             {
  [07:16:40.892]                 if (substitute) 
  [07:16:40.892]                   expr <- substitute(expr)
  [07:16:40.892]                 local <- as.logical(local)
  [07:16:40.892]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.892]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.892]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.892]                   label = label, ...)
  [07:16:40.892]                 if (!future$lazy) 
  [07:16:40.892]                   future <- run(future)
  [07:16:40.892]                 invisible(future)
  [07:16:40.892]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.892]         }
  [07:16:40.892]         base::options(...future.oldOptions)
  [07:16:40.892]     })
  [07:16:40.892]     Sys.time
  [07:16:40.892]     if (base::is.na(NA)) {
  [07:16:40.892]     }
  [07:16:40.892]     else {
  [07:16:40.892]         base::sink(type = "output", split = FALSE)
  [07:16:40.892]         if (NA) {
  [07:16:40.892]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.892]         }
  [07:16:40.892]         else {
  [07:16:40.892]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.892]         }
  [07:16:40.892]         base::close(...future.stdout)
  [07:16:40.892]         ...future.stdout <- NULL
  [07:16:40.892]     }
  [07:16:40.892]     ...future.result$conditions <- ...future.conditions
  [07:16:40.892]     ...future.result
  [07:16:40.892] }
  [07:16:40.896] plan(): Setting new future strategy stack:
  [07:16:40.896] List of future strategies:
  [07:16:40.896] 1. sequential:
  [07:16:40.896]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.896]    - tweaked: FALSE
  [07:16:40.896]    - call: NULL
  [07:16:40.898] plan(): nbrOfWorkers() = 1
  [07:16:40.900] Packages needed by the future expression (n = 0): <none>
  [07:16:40.900] Packages needed by future strategies (n = 0): <none>
  [07:16:40.904] {
  [07:16:40.904]     {
  [07:16:40.904]         ...future.startTime <- base::Sys.time()
  [07:16:40.904]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.904]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.904]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.904]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.904]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.904]         {
  [07:16:40.904]             {
  [07:16:40.904]                 base::local({
  [07:16:40.904]                   has_future <- base::requireNamespace("future", 
  [07:16:40.904]                     quietly = TRUE)
  [07:16:40.904]                   version <- if (has_future) 
  [07:16:40.904]                     utils::packageVersion("future")
  [07:16:40.904]                   else NULL
  [07:16:40.904]                   if (!has_future || version < "1.8.0") {
  [07:16:40.904]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.904]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.904]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.904]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.904]                         "release", "version")], collapse = " "), 
  [07:16:40.904]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.904]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.904]                       info)
  [07:16:40.904]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.904]                     if (!has_future) {
  [07:16:40.904]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.904]                         info)
  [07:16:40.904]                     }
  [07:16:40.904]                     else {
  [07:16:40.904]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.904]                         info, version)
  [07:16:40.904]                     }
  [07:16:40.904]                     base::stop(msg)
  [07:16:40.904]                   }
  [07:16:40.904]                 })
  [07:16:40.904]             }
  [07:16:40.904]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.904]         }
  [07:16:40.904]     }
  [07:16:40.904]     if (base::is.na(NA)) {
  [07:16:40.904]     }
  [07:16:40.904]     else {
  [07:16:40.904]         if (NA) {
  [07:16:40.904]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.904]                 open = "w")
  [07:16:40.904]         }
  [07:16:40.904]         else {
  [07:16:40.904]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.904]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.904]         }
  [07:16:40.904]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.904]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.904]             base::sink(type = "output", split = FALSE)
  [07:16:40.904]             base::close(...future.stdout)
  [07:16:40.904]         }, add = TRUE)
  [07:16:40.904]     }
  [07:16:40.904]     ...future.frame <- base::sys.nframe()
  [07:16:40.904]     ...future.conditions <- base::list()
  [07:16:40.904]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.904]     ...future.result <- base::tryCatch({
  [07:16:40.904]         base::withCallingHandlers({
  [07:16:40.904]             ...future.value <- base::withVisible(base::local({
  [07:16:40.904]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.904]             }))
  [07:16:40.904]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.904]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.904]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.904]                 version = "1.8")
  [07:16:40.904]         }, condition = base::local({
  [07:16:40.904]             c <- base::c
  [07:16:40.904]             inherits <- base::inherits
  [07:16:40.904]             invokeRestart <- base::invokeRestart
  [07:16:40.904]             length <- base::length
  [07:16:40.904]             list <- base::list
  [07:16:40.904]             seq.int <- base::seq.int
  [07:16:40.904]             signalCondition <- base::signalCondition
  [07:16:40.904]             sys.calls <- base::sys.calls
  [07:16:40.904]             Sys.time <- base::Sys.time
  [07:16:40.904]             `[[` <- base::`[[`
  [07:16:40.904]             `+` <- base::`+`
  [07:16:40.904]             `<<-` <- base::`<<-`
  [07:16:40.904]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.904]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.904]                   3L)]
  [07:16:40.904]             }
  [07:16:40.904]             function(cond) {
  [07:16:40.904]                 if (inherits(cond, "error")) {
  [07:16:40.904]                   sessionInformation <- function() {
  [07:16:40.904]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.904]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.904]                       search = base::search(), system = base::Sys.info())
  [07:16:40.904]                   }
  [07:16:40.904]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.904]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.904]                     cond$call), session = sessionInformation(), 
  [07:16:40.904]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.904]                   signalCondition(cond)
  [07:16:40.904]                 }
  [07:16:40.904]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.904]                 ))) {
  [07:16:40.904]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.904]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.904]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.904]                   if (!signal) {
  [07:16:40.904]                     muffleCondition <- function (cond) 
  [07:16:40.904]                     {
  [07:16:40.904]                       inherits <- base::inherits
  [07:16:40.904]                       invokeRestart <- base::invokeRestart
  [07:16:40.904]                       muffled <- FALSE
  [07:16:40.904]                       if (inherits(cond, "message")) {
  [07:16:40.904]                         invokeRestart("muffleMessage")
  [07:16:40.904]                         muffled <- TRUE
  [07:16:40.904]                       }
  [07:16:40.904]                       else if (inherits(cond, "warning")) {
  [07:16:40.904]                         invokeRestart("muffleWarning")
  [07:16:40.904]                         muffled <- TRUE
  [07:16:40.904]                       }
  [07:16:40.904]                       else if (inherits(cond, "condition")) {
  [07:16:40.904]                         computeRestarts <- base::computeRestarts
  [07:16:40.904]                         grepl <- base::grepl
  [07:16:40.904]                         is.null <- base::is.null
  [07:16:40.904]                         restarts <- computeRestarts(cond)
  [07:16:40.904]                         for (restart in restarts) {
  [07:16:40.904]                           name <- restart$name
  [07:16:40.904]                           if (is.null(name)) 
  [07:16:40.904]                             next
  [07:16:40.904]                           if (!grepl("^muffle", name)) 
  [07:16:40.904]                             next
  [07:16:40.904]                           invokeRestart(restart)
  [07:16:40.904]                           muffled <- TRUE
  [07:16:40.904]                           break
  [07:16:40.904]                         }
  [07:16:40.904]                       }
  [07:16:40.904]                       invisible(muffled)
  [07:16:40.904]                     }
  [07:16:40.904]                     muffleCondition(cond)
  [07:16:40.904]                   }
  [07:16:40.904]                 }
  [07:16:40.904]             }
  [07:16:40.904]         }))
  [07:16:40.904]     }, error = function(ex) {
  [07:16:40.904]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.904]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.904]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.904]     }, finally = {
  [07:16:40.904]         {
  [07:16:40.904]             NULL
  [07:16:40.904]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.904]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.904]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.904]                 label = NULL, ...) 
  [07:16:40.904]             {
  [07:16:40.904]                 if (substitute) 
  [07:16:40.904]                   expr <- substitute(expr)
  [07:16:40.904]                 local <- as.logical(local)
  [07:16:40.904]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.904]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.904]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.904]                   label = label, ...)
  [07:16:40.904]                 if (!future$lazy) 
  [07:16:40.904]                   future <- run(future)
  [07:16:40.904]                 invisible(future)
  [07:16:40.904]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.904]         }
  [07:16:40.904]         base::options(...future.oldOptions)
  [07:16:40.904]     })
  [07:16:40.904]     Sys.time
  [07:16:40.904]     if (base::is.na(NA)) {
  [07:16:40.904]     }
  [07:16:40.904]     else {
  [07:16:40.904]         base::sink(type = "output", split = FALSE)
  [07:16:40.904]         if (NA) {
  [07:16:40.904]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.904]         }
  [07:16:40.904]         else {
  [07:16:40.904]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.904]         }
  [07:16:40.904]         base::close(...future.stdout)
  [07:16:40.904]         ...future.stdout <- NULL
  [07:16:40.904]     }
  [07:16:40.904]     ...future.result$conditions <- ...future.conditions
  [07:16:40.904]     ...future.result
  [07:16:40.904] }
  [07:16:40.908] plan(): Setting new future strategy stack:
  [07:16:40.909] List of future strategies:
  [07:16:40.909] 1. sequential:
  [07:16:40.909]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.909]    - tweaked: FALSE
  [07:16:40.909]    - call: NULL
  [07:16:40.910] plan(): nbrOfWorkers() = 1
  [07:16:40.912] Packages needed by the future expression (n = 0): <none>
  [07:16:40.913] Packages needed by future strategies (n = 0): <none>
  [07:16:40.917] {
  [07:16:40.917]     {
  [07:16:40.917]         ...future.startTime <- base::Sys.time()
  [07:16:40.917]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.917]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.917]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.917]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.917]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.917]         {
  [07:16:40.917]             {
  [07:16:40.917]                 base::local({
  [07:16:40.917]                   has_future <- base::requireNamespace("future", 
  [07:16:40.917]                     quietly = TRUE)
  [07:16:40.917]                   version <- if (has_future) 
  [07:16:40.917]                     utils::packageVersion("future")
  [07:16:40.917]                   else NULL
  [07:16:40.917]                   if (!has_future || version < "1.8.0") {
  [07:16:40.917]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.917]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.917]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.917]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.917]                         "release", "version")], collapse = " "), 
  [07:16:40.917]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.917]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.917]                       info)
  [07:16:40.917]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.917]                     if (!has_future) {
  [07:16:40.917]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.917]                         info)
  [07:16:40.917]                     }
  [07:16:40.917]                     else {
  [07:16:40.917]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.917]                         info, version)
  [07:16:40.917]                     }
  [07:16:40.917]                     base::stop(msg)
  [07:16:40.917]                   }
  [07:16:40.917]                 })
  [07:16:40.917]             }
  [07:16:40.917]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.917]         }
  [07:16:40.917]     }
  [07:16:40.917]     if (base::is.na(NA)) {
  [07:16:40.917]     }
  [07:16:40.917]     else {
  [07:16:40.917]         if (NA) {
  [07:16:40.917]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.917]                 open = "w")
  [07:16:40.917]         }
  [07:16:40.917]         else {
  [07:16:40.917]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.917]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.917]         }
  [07:16:40.917]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.917]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.917]             base::sink(type = "output", split = FALSE)
  [07:16:40.917]             base::close(...future.stdout)
  [07:16:40.917]         }, add = TRUE)
  [07:16:40.917]     }
  [07:16:40.917]     ...future.frame <- base::sys.nframe()
  [07:16:40.917]     ...future.conditions <- base::list()
  [07:16:40.917]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.917]     ...future.result <- base::tryCatch({
  [07:16:40.917]         base::withCallingHandlers({
  [07:16:40.917]             ...future.value <- base::withVisible(base::local({
  [07:16:40.917]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.917]             }))
  [07:16:40.917]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.917]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.917]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.917]                 version = "1.8")
  [07:16:40.917]         }, condition = base::local({
  [07:16:40.917]             c <- base::c
  [07:16:40.917]             inherits <- base::inherits
  [07:16:40.917]             invokeRestart <- base::invokeRestart
  [07:16:40.917]             length <- base::length
  [07:16:40.917]             list <- base::list
  [07:16:40.917]             seq.int <- base::seq.int
  [07:16:40.917]             signalCondition <- base::signalCondition
  [07:16:40.917]             sys.calls <- base::sys.calls
  [07:16:40.917]             Sys.time <- base::Sys.time
  [07:16:40.917]             `[[` <- base::`[[`
  [07:16:40.917]             `+` <- base::`+`
  [07:16:40.917]             `<<-` <- base::`<<-`
  [07:16:40.917]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.917]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.917]                   3L)]
  [07:16:40.917]             }
  [07:16:40.917]             function(cond) {
  [07:16:40.917]                 if (inherits(cond, "error")) {
  [07:16:40.917]                   sessionInformation <- function() {
  [07:16:40.917]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.917]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.917]                       search = base::search(), system = base::Sys.info())
  [07:16:40.917]                   }
  [07:16:40.917]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.917]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.917]                     cond$call), session = sessionInformation(), 
  [07:16:40.917]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.917]                   signalCondition(cond)
  [07:16:40.917]                 }
  [07:16:40.917]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.917]                 ))) {
  [07:16:40.917]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.917]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.917]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.917]                   if (!signal) {
  [07:16:40.917]                     muffleCondition <- function (cond) 
  [07:16:40.917]                     {
  [07:16:40.917]                       inherits <- base::inherits
  [07:16:40.917]                       invokeRestart <- base::invokeRestart
  [07:16:40.917]                       muffled <- FALSE
  [07:16:40.917]                       if (inherits(cond, "message")) {
  [07:16:40.917]                         invokeRestart("muffleMessage")
  [07:16:40.917]                         muffled <- TRUE
  [07:16:40.917]                       }
  [07:16:40.917]                       else if (inherits(cond, "warning")) {
  [07:16:40.917]                         invokeRestart("muffleWarning")
  [07:16:40.917]                         muffled <- TRUE
  [07:16:40.917]                       }
  [07:16:40.917]                       else if (inherits(cond, "condition")) {
  [07:16:40.917]                         computeRestarts <- base::computeRestarts
  [07:16:40.917]                         grepl <- base::grepl
  [07:16:40.917]                         is.null <- base::is.null
  [07:16:40.917]                         restarts <- computeRestarts(cond)
  [07:16:40.917]                         for (restart in restarts) {
  [07:16:40.917]                           name <- restart$name
  [07:16:40.917]                           if (is.null(name)) 
  [07:16:40.917]                             next
  [07:16:40.917]                           if (!grepl("^muffle", name)) 
  [07:16:40.917]                             next
  [07:16:40.917]                           invokeRestart(restart)
  [07:16:40.917]                           muffled <- TRUE
  [07:16:40.917]                           break
  [07:16:40.917]                         }
  [07:16:40.917]                       }
  [07:16:40.917]                       invisible(muffled)
  [07:16:40.917]                     }
  [07:16:40.917]                     muffleCondition(cond)
  [07:16:40.917]                   }
  [07:16:40.917]                 }
  [07:16:40.917]             }
  [07:16:40.917]         }))
  [07:16:40.917]     }, error = function(ex) {
  [07:16:40.917]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.917]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.917]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.917]     }, finally = {
  [07:16:40.917]         {
  [07:16:40.917]             NULL
  [07:16:40.917]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.917]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.917]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.917]                 label = NULL, ...) 
  [07:16:40.917]             {
  [07:16:40.917]                 if (substitute) 
  [07:16:40.917]                   expr <- substitute(expr)
  [07:16:40.917]                 local <- as.logical(local)
  [07:16:40.917]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.917]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.917]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.917]                   label = label, ...)
  [07:16:40.917]                 if (!future$lazy) 
  [07:16:40.917]                   future <- run(future)
  [07:16:40.917]                 invisible(future)
  [07:16:40.917]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.917]         }
  [07:16:40.917]         base::options(...future.oldOptions)
  [07:16:40.917]     })
  [07:16:40.917]     Sys.time
  [07:16:40.917]     if (base::is.na(NA)) {
  [07:16:40.917]     }
  [07:16:40.917]     else {
  [07:16:40.917]         base::sink(type = "output", split = FALSE)
  [07:16:40.917]         if (NA) {
  [07:16:40.917]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.917]         }
  [07:16:40.917]         else {
  [07:16:40.917]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.917]         }
  [07:16:40.917]         base::close(...future.stdout)
  [07:16:40.917]         ...future.stdout <- NULL
  [07:16:40.917]     }
  [07:16:40.917]     ...future.result$conditions <- ...future.conditions
  [07:16:40.917]     ...future.result
  [07:16:40.917] }
  [07:16:40.921] plan(): Setting new future strategy stack:
  [07:16:40.921] List of future strategies:
  [07:16:40.921] 1. sequential:
  [07:16:40.921]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.921]    - tweaked: FALSE
  [07:16:40.921]    - call: NULL
  [07:16:40.923] plan(): nbrOfWorkers() = 1
  [07:16:40.927] Packages needed by the future expression (n = 0): <none>
  [07:16:40.928] Packages needed by future strategies (n = 0): <none>
  [07:16:40.932] {
  [07:16:40.932]     {
  [07:16:40.932]         ...future.startTime <- base::Sys.time()
  [07:16:40.932]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.932]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.932]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.932]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.932]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.932]         {
  [07:16:40.932]             {
  [07:16:40.932]                 base::local({
  [07:16:40.932]                   has_future <- base::requireNamespace("future", 
  [07:16:40.932]                     quietly = TRUE)
  [07:16:40.932]                   version <- if (has_future) 
  [07:16:40.932]                     utils::packageVersion("future")
  [07:16:40.932]                   else NULL
  [07:16:40.932]                   if (!has_future || version < "1.8.0") {
  [07:16:40.932]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.932]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.932]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.932]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.932]                         "release", "version")], collapse = " "), 
  [07:16:40.932]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.932]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.932]                       info)
  [07:16:40.932]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.932]                     if (!has_future) {
  [07:16:40.932]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.932]                         info)
  [07:16:40.932]                     }
  [07:16:40.932]                     else {
  [07:16:40.932]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.932]                         info, version)
  [07:16:40.932]                     }
  [07:16:40.932]                     base::stop(msg)
  [07:16:40.932]                   }
  [07:16:40.932]                 })
  [07:16:40.932]             }
  [07:16:40.932]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.932]         }
  [07:16:40.932]     }
  [07:16:40.932]     if (base::is.na(NA)) {
  [07:16:40.932]     }
  [07:16:40.932]     else {
  [07:16:40.932]         if (NA) {
  [07:16:40.932]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.932]                 open = "w")
  [07:16:40.932]         }
  [07:16:40.932]         else {
  [07:16:40.932]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.932]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.932]         }
  [07:16:40.932]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.932]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.932]             base::sink(type = "output", split = FALSE)
  [07:16:40.932]             base::close(...future.stdout)
  [07:16:40.932]         }, add = TRUE)
  [07:16:40.932]     }
  [07:16:40.932]     ...future.frame <- base::sys.nframe()
  [07:16:40.932]     ...future.conditions <- base::list()
  [07:16:40.932]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.932]     ...future.result <- base::tryCatch({
  [07:16:40.932]         base::withCallingHandlers({
  [07:16:40.932]             ...future.value <- base::withVisible(base::local({
  [07:16:40.932]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.932]             }))
  [07:16:40.932]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.932]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.932]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.932]                 version = "1.8")
  [07:16:40.932]         }, condition = base::local({
  [07:16:40.932]             c <- base::c
  [07:16:40.932]             inherits <- base::inherits
  [07:16:40.932]             invokeRestart <- base::invokeRestart
  [07:16:40.932]             length <- base::length
  [07:16:40.932]             list <- base::list
  [07:16:40.932]             seq.int <- base::seq.int
  [07:16:40.932]             signalCondition <- base::signalCondition
  [07:16:40.932]             sys.calls <- base::sys.calls
  [07:16:40.932]             Sys.time <- base::Sys.time
  [07:16:40.932]             `[[` <- base::`[[`
  [07:16:40.932]             `+` <- base::`+`
  [07:16:40.932]             `<<-` <- base::`<<-`
  [07:16:40.932]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.932]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.932]                   3L)]
  [07:16:40.932]             }
  [07:16:40.932]             function(cond) {
  [07:16:40.932]                 if (inherits(cond, "error")) {
  [07:16:40.932]                   sessionInformation <- function() {
  [07:16:40.932]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.932]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.932]                       search = base::search(), system = base::Sys.info())
  [07:16:40.932]                   }
  [07:16:40.932]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.932]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.932]                     cond$call), session = sessionInformation(), 
  [07:16:40.932]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.932]                   signalCondition(cond)
  [07:16:40.932]                 }
  [07:16:40.932]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.932]                 ))) {
  [07:16:40.932]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.932]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.932]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.932]                   if (!signal) {
  [07:16:40.932]                     muffleCondition <- function (cond) 
  [07:16:40.932]                     {
  [07:16:40.932]                       inherits <- base::inherits
  [07:16:40.932]                       invokeRestart <- base::invokeRestart
  [07:16:40.932]                       muffled <- FALSE
  [07:16:40.932]                       if (inherits(cond, "message")) {
  [07:16:40.932]                         invokeRestart("muffleMessage")
  [07:16:40.932]                         muffled <- TRUE
  [07:16:40.932]                       }
  [07:16:40.932]                       else if (inherits(cond, "warning")) {
  [07:16:40.932]                         invokeRestart("muffleWarning")
  [07:16:40.932]                         muffled <- TRUE
  [07:16:40.932]                       }
  [07:16:40.932]                       else if (inherits(cond, "condition")) {
  [07:16:40.932]                         computeRestarts <- base::computeRestarts
  [07:16:40.932]                         grepl <- base::grepl
  [07:16:40.932]                         is.null <- base::is.null
  [07:16:40.932]                         restarts <- computeRestarts(cond)
  [07:16:40.932]                         for (restart in restarts) {
  [07:16:40.932]                           name <- restart$name
  [07:16:40.932]                           if (is.null(name)) 
  [07:16:40.932]                             next
  [07:16:40.932]                           if (!grepl("^muffle", name)) 
  [07:16:40.932]                             next
  [07:16:40.932]                           invokeRestart(restart)
  [07:16:40.932]                           muffled <- TRUE
  [07:16:40.932]                           break
  [07:16:40.932]                         }
  [07:16:40.932]                       }
  [07:16:40.932]                       invisible(muffled)
  [07:16:40.932]                     }
  [07:16:40.932]                     muffleCondition(cond)
  [07:16:40.932]                   }
  [07:16:40.932]                 }
  [07:16:40.932]             }
  [07:16:40.932]         }))
  [07:16:40.932]     }, error = function(ex) {
  [07:16:40.932]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.932]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.932]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.932]     }, finally = {
  [07:16:40.932]         {
  [07:16:40.932]             NULL
  [07:16:40.932]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.932]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.932]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.932]                 label = NULL, ...) 
  [07:16:40.932]             {
  [07:16:40.932]                 if (substitute) 
  [07:16:40.932]                   expr <- substitute(expr)
  [07:16:40.932]                 local <- as.logical(local)
  [07:16:40.932]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.932]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.932]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.932]                   label = label, ...)
  [07:16:40.932]                 if (!future$lazy) 
  [07:16:40.932]                   future <- run(future)
  [07:16:40.932]                 invisible(future)
  [07:16:40.932]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.932]         }
  [07:16:40.932]         base::options(...future.oldOptions)
  [07:16:40.932]     })
  [07:16:40.932]     Sys.time
  [07:16:40.932]     if (base::is.na(NA)) {
  [07:16:40.932]     }
  [07:16:40.932]     else {
  [07:16:40.932]         base::sink(type = "output", split = FALSE)
  [07:16:40.932]         if (NA) {
  [07:16:40.932]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.932]         }
  [07:16:40.932]         else {
  [07:16:40.932]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.932]         }
  [07:16:40.932]         base::close(...future.stdout)
  [07:16:40.932]         ...future.stdout <- NULL
  [07:16:40.932]     }
  [07:16:40.932]     ...future.result$conditions <- ...future.conditions
  [07:16:40.932]     ...future.result
  [07:16:40.932] }
  [07:16:40.936] plan(): Setting new future strategy stack:
  [07:16:40.937] List of future strategies:
  [07:16:40.937] 1. sequential:
  [07:16:40.937]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.937]    - tweaked: FALSE
  [07:16:40.937]    - call: NULL
  [07:16:40.938] plan(): nbrOfWorkers() = 1
  [07:16:40.940] Packages needed by the future expression (n = 0): <none>
  [07:16:40.941] Packages needed by future strategies (n = 0): <none>
  [07:16:40.945] {
  [07:16:40.945]     {
  [07:16:40.945]         ...future.startTime <- base::Sys.time()
  [07:16:40.945]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.945]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.945]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.945]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.945]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.945]         {
  [07:16:40.945]             {
  [07:16:40.945]                 base::local({
  [07:16:40.945]                   has_future <- base::requireNamespace("future", 
  [07:16:40.945]                     quietly = TRUE)
  [07:16:40.945]                   version <- if (has_future) 
  [07:16:40.945]                     utils::packageVersion("future")
  [07:16:40.945]                   else NULL
  [07:16:40.945]                   if (!has_future || version < "1.8.0") {
  [07:16:40.945]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.945]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.945]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.945]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.945]                         "release", "version")], collapse = " "), 
  [07:16:40.945]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.945]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.945]                       info)
  [07:16:40.945]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.945]                     if (!has_future) {
  [07:16:40.945]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.945]                         info)
  [07:16:40.945]                     }
  [07:16:40.945]                     else {
  [07:16:40.945]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.945]                         info, version)
  [07:16:40.945]                     }
  [07:16:40.945]                     base::stop(msg)
  [07:16:40.945]                   }
  [07:16:40.945]                 })
  [07:16:40.945]             }
  [07:16:40.945]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.945]         }
  [07:16:40.945]     }
  [07:16:40.945]     if (base::is.na(NA)) {
  [07:16:40.945]     }
  [07:16:40.945]     else {
  [07:16:40.945]         if (NA) {
  [07:16:40.945]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.945]                 open = "w")
  [07:16:40.945]         }
  [07:16:40.945]         else {
  [07:16:40.945]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.945]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.945]         }
  [07:16:40.945]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.945]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.945]             base::sink(type = "output", split = FALSE)
  [07:16:40.945]             base::close(...future.stdout)
  [07:16:40.945]         }, add = TRUE)
  [07:16:40.945]     }
  [07:16:40.945]     ...future.frame <- base::sys.nframe()
  [07:16:40.945]     ...future.conditions <- base::list()
  [07:16:40.945]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.945]     ...future.result <- base::tryCatch({
  [07:16:40.945]         base::withCallingHandlers({
  [07:16:40.945]             ...future.value <- base::withVisible(base::local({
  [07:16:40.945]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.945]             }))
  [07:16:40.945]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.945]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.945]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.945]                 version = "1.8")
  [07:16:40.945]         }, condition = base::local({
  [07:16:40.945]             c <- base::c
  [07:16:40.945]             inherits <- base::inherits
  [07:16:40.945]             invokeRestart <- base::invokeRestart
  [07:16:40.945]             length <- base::length
  [07:16:40.945]             list <- base::list
  [07:16:40.945]             seq.int <- base::seq.int
  [07:16:40.945]             signalCondition <- base::signalCondition
  [07:16:40.945]             sys.calls <- base::sys.calls
  [07:16:40.945]             Sys.time <- base::Sys.time
  [07:16:40.945]             `[[` <- base::`[[`
  [07:16:40.945]             `+` <- base::`+`
  [07:16:40.945]             `<<-` <- base::`<<-`
  [07:16:40.945]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.945]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.945]                   3L)]
  [07:16:40.945]             }
  [07:16:40.945]             function(cond) {
  [07:16:40.945]                 if (inherits(cond, "error")) {
  [07:16:40.945]                   sessionInformation <- function() {
  [07:16:40.945]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.945]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.945]                       search = base::search(), system = base::Sys.info())
  [07:16:40.945]                   }
  [07:16:40.945]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.945]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.945]                     cond$call), session = sessionInformation(), 
  [07:16:40.945]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.945]                   signalCondition(cond)
  [07:16:40.945]                 }
  [07:16:40.945]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.945]                 ))) {
  [07:16:40.945]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.945]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.945]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.945]                   if (!signal) {
  [07:16:40.945]                     muffleCondition <- function (cond) 
  [07:16:40.945]                     {
  [07:16:40.945]                       inherits <- base::inherits
  [07:16:40.945]                       invokeRestart <- base::invokeRestart
  [07:16:40.945]                       muffled <- FALSE
  [07:16:40.945]                       if (inherits(cond, "message")) {
  [07:16:40.945]                         invokeRestart("muffleMessage")
  [07:16:40.945]                         muffled <- TRUE
  [07:16:40.945]                       }
  [07:16:40.945]                       else if (inherits(cond, "warning")) {
  [07:16:40.945]                         invokeRestart("muffleWarning")
  [07:16:40.945]                         muffled <- TRUE
  [07:16:40.945]                       }
  [07:16:40.945]                       else if (inherits(cond, "condition")) {
  [07:16:40.945]                         computeRestarts <- base::computeRestarts
  [07:16:40.945]                         grepl <- base::grepl
  [07:16:40.945]                         is.null <- base::is.null
  [07:16:40.945]                         restarts <- computeRestarts(cond)
  [07:16:40.945]                         for (restart in restarts) {
  [07:16:40.945]                           name <- restart$name
  [07:16:40.945]                           if (is.null(name)) 
  [07:16:40.945]                             next
  [07:16:40.945]                           if (!grepl("^muffle", name)) 
  [07:16:40.945]                             next
  [07:16:40.945]                           invokeRestart(restart)
  [07:16:40.945]                           muffled <- TRUE
  [07:16:40.945]                           break
  [07:16:40.945]                         }
  [07:16:40.945]                       }
  [07:16:40.945]                       invisible(muffled)
  [07:16:40.945]                     }
  [07:16:40.945]                     muffleCondition(cond)
  [07:16:40.945]                   }
  [07:16:40.945]                 }
  [07:16:40.945]             }
  [07:16:40.945]         }))
  [07:16:40.945]     }, error = function(ex) {
  [07:16:40.945]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.945]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.945]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.945]     }, finally = {
  [07:16:40.945]         {
  [07:16:40.945]             NULL
  [07:16:40.945]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.945]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.945]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.945]                 label = NULL, ...) 
  [07:16:40.945]             {
  [07:16:40.945]                 if (substitute) 
  [07:16:40.945]                   expr <- substitute(expr)
  [07:16:40.945]                 local <- as.logical(local)
  [07:16:40.945]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.945]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.945]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.945]                   label = label, ...)
  [07:16:40.945]                 if (!future$lazy) 
  [07:16:40.945]                   future <- run(future)
  [07:16:40.945]                 invisible(future)
  [07:16:40.945]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.945]         }
  [07:16:40.945]         base::options(...future.oldOptions)
  [07:16:40.945]     })
  [07:16:40.945]     Sys.time
  [07:16:40.945]     if (base::is.na(NA)) {
  [07:16:40.945]     }
  [07:16:40.945]     else {
  [07:16:40.945]         base::sink(type = "output", split = FALSE)
  [07:16:40.945]         if (NA) {
  [07:16:40.945]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.945]         }
  [07:16:40.945]         else {
  [07:16:40.945]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.945]         }
  [07:16:40.945]         base::close(...future.stdout)
  [07:16:40.945]         ...future.stdout <- NULL
  [07:16:40.945]     }
  [07:16:40.945]     ...future.result$conditions <- ...future.conditions
  [07:16:40.945]     ...future.result
  [07:16:40.945] }
  [07:16:40.949] plan(): Setting new future strategy stack:
  [07:16:40.950] List of future strategies:
  [07:16:40.950] 1. sequential:
  [07:16:40.950]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.950]    - tweaked: FALSE
  [07:16:40.950]    - call: NULL
  [07:16:40.952] plan(): nbrOfWorkers() = 1
  [07:16:40.954] Packages needed by the future expression (n = 0): <none>
  [07:16:40.955] Packages needed by future strategies (n = 0): <none>
  [07:16:40.959] {
  [07:16:40.959]     {
  [07:16:40.959]         ...future.startTime <- base::Sys.time()
  [07:16:40.959]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.959]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.959]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.959]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.959]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.959]         {
  [07:16:40.959]             {
  [07:16:40.959]                 base::local({
  [07:16:40.959]                   has_future <- base::requireNamespace("future", 
  [07:16:40.959]                     quietly = TRUE)
  [07:16:40.959]                   version <- if (has_future) 
  [07:16:40.959]                     utils::packageVersion("future")
  [07:16:40.959]                   else NULL
  [07:16:40.959]                   if (!has_future || version < "1.8.0") {
  [07:16:40.959]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.959]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.959]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.959]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.959]                         "release", "version")], collapse = " "), 
  [07:16:40.959]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.959]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.959]                       info)
  [07:16:40.959]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.959]                     if (!has_future) {
  [07:16:40.959]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.959]                         info)
  [07:16:40.959]                     }
  [07:16:40.959]                     else {
  [07:16:40.959]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.959]                         info, version)
  [07:16:40.959]                     }
  [07:16:40.959]                     base::stop(msg)
  [07:16:40.959]                   }
  [07:16:40.959]                 })
  [07:16:40.959]             }
  [07:16:40.959]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.959]         }
  [07:16:40.959]     }
  [07:16:40.959]     if (base::is.na(NA)) {
  [07:16:40.959]     }
  [07:16:40.959]     else {
  [07:16:40.959]         if (NA) {
  [07:16:40.959]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.959]                 open = "w")
  [07:16:40.959]         }
  [07:16:40.959]         else {
  [07:16:40.959]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.959]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.959]         }
  [07:16:40.959]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.959]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.959]             base::sink(type = "output", split = FALSE)
  [07:16:40.959]             base::close(...future.stdout)
  [07:16:40.959]         }, add = TRUE)
  [07:16:40.959]     }
  [07:16:40.959]     ...future.frame <- base::sys.nframe()
  [07:16:40.959]     ...future.conditions <- base::list()
  [07:16:40.959]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.959]     ...future.result <- base::tryCatch({
  [07:16:40.959]         base::withCallingHandlers({
  [07:16:40.959]             ...future.value <- base::withVisible(base::local({
  [07:16:40.959]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.959]             }))
  [07:16:40.959]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.959]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.959]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.959]                 version = "1.8")
  [07:16:40.959]         }, condition = base::local({
  [07:16:40.959]             c <- base::c
  [07:16:40.959]             inherits <- base::inherits
  [07:16:40.959]             invokeRestart <- base::invokeRestart
  [07:16:40.959]             length <- base::length
  [07:16:40.959]             list <- base::list
  [07:16:40.959]             seq.int <- base::seq.int
  [07:16:40.959]             signalCondition <- base::signalCondition
  [07:16:40.959]             sys.calls <- base::sys.calls
  [07:16:40.959]             Sys.time <- base::Sys.time
  [07:16:40.959]             `[[` <- base::`[[`
  [07:16:40.959]             `+` <- base::`+`
  [07:16:40.959]             `<<-` <- base::`<<-`
  [07:16:40.959]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.959]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.959]                   3L)]
  [07:16:40.959]             }
  [07:16:40.959]             function(cond) {
  [07:16:40.959]                 if (inherits(cond, "error")) {
  [07:16:40.959]                   sessionInformation <- function() {
  [07:16:40.959]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.959]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.959]                       search = base::search(), system = base::Sys.info())
  [07:16:40.959]                   }
  [07:16:40.959]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.959]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.959]                     cond$call), session = sessionInformation(), 
  [07:16:40.959]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.959]                   signalCondition(cond)
  [07:16:40.959]                 }
  [07:16:40.959]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.959]                 ))) {
  [07:16:40.959]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.959]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.959]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.959]                   if (!signal) {
  [07:16:40.959]                     muffleCondition <- function (cond) 
  [07:16:40.959]                     {
  [07:16:40.959]                       inherits <- base::inherits
  [07:16:40.959]                       invokeRestart <- base::invokeRestart
  [07:16:40.959]                       muffled <- FALSE
  [07:16:40.959]                       if (inherits(cond, "message")) {
  [07:16:40.959]                         invokeRestart("muffleMessage")
  [07:16:40.959]                         muffled <- TRUE
  [07:16:40.959]                       }
  [07:16:40.959]                       else if (inherits(cond, "warning")) {
  [07:16:40.959]                         invokeRestart("muffleWarning")
  [07:16:40.959]                         muffled <- TRUE
  [07:16:40.959]                       }
  [07:16:40.959]                       else if (inherits(cond, "condition")) {
  [07:16:40.959]                         computeRestarts <- base::computeRestarts
  [07:16:40.959]                         grepl <- base::grepl
  [07:16:40.959]                         is.null <- base::is.null
  [07:16:40.959]                         restarts <- computeRestarts(cond)
  [07:16:40.959]                         for (restart in restarts) {
  [07:16:40.959]                           name <- restart$name
  [07:16:40.959]                           if (is.null(name)) 
  [07:16:40.959]                             next
  [07:16:40.959]                           if (!grepl("^muffle", name)) 
  [07:16:40.959]                             next
  [07:16:40.959]                           invokeRestart(restart)
  [07:16:40.959]                           muffled <- TRUE
  [07:16:40.959]                           break
  [07:16:40.959]                         }
  [07:16:40.959]                       }
  [07:16:40.959]                       invisible(muffled)
  [07:16:40.959]                     }
  [07:16:40.959]                     muffleCondition(cond)
  [07:16:40.959]                   }
  [07:16:40.959]                 }
  [07:16:40.959]             }
  [07:16:40.959]         }))
  [07:16:40.959]     }, error = function(ex) {
  [07:16:40.959]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.959]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.959]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.959]     }, finally = {
  [07:16:40.959]         {
  [07:16:40.959]             NULL
  [07:16:40.959]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.959]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.959]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.959]                 label = NULL, ...) 
  [07:16:40.959]             {
  [07:16:40.959]                 if (substitute) 
  [07:16:40.959]                   expr <- substitute(expr)
  [07:16:40.959]                 local <- as.logical(local)
  [07:16:40.959]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.959]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.959]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.959]                   label = label, ...)
  [07:16:40.959]                 if (!future$lazy) 
  [07:16:40.959]                   future <- run(future)
  [07:16:40.959]                 invisible(future)
  [07:16:40.959]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.959]         }
  [07:16:40.959]         base::options(...future.oldOptions)
  [07:16:40.959]     })
  [07:16:40.959]     Sys.time
  [07:16:40.959]     if (base::is.na(NA)) {
  [07:16:40.959]     }
  [07:16:40.959]     else {
  [07:16:40.959]         base::sink(type = "output", split = FALSE)
  [07:16:40.959]         if (NA) {
  [07:16:40.959]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.959]         }
  [07:16:40.959]         else {
  [07:16:40.959]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.959]         }
  [07:16:40.959]         base::close(...future.stdout)
  [07:16:40.959]         ...future.stdout <- NULL
  [07:16:40.959]     }
  [07:16:40.959]     ...future.result$conditions <- ...future.conditions
  [07:16:40.959]     ...future.result
  [07:16:40.959] }
  [07:16:40.963] plan(): Setting new future strategy stack:
  [07:16:40.964] List of future strategies:
  [07:16:40.964] 1. sequential:
  [07:16:40.964]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.964]    - tweaked: FALSE
  [07:16:40.964]    - call: NULL
  [07:16:40.966] plan(): nbrOfWorkers() = 1
  [07:16:40.968] Packages needed by the future expression (n = 0): <none>
  [07:16:40.969] Packages needed by future strategies (n = 0): <none>
  [07:16:40.973] {
  [07:16:40.973]     {
  [07:16:40.973]         ...future.startTime <- base::Sys.time()
  [07:16:40.973]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.973]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.973]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.973]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.973]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.973]         {
  [07:16:40.973]             {
  [07:16:40.973]                 base::local({
  [07:16:40.973]                   has_future <- base::requireNamespace("future", 
  [07:16:40.973]                     quietly = TRUE)
  [07:16:40.973]                   version <- if (has_future) 
  [07:16:40.973]                     utils::packageVersion("future")
  [07:16:40.973]                   else NULL
  [07:16:40.973]                   if (!has_future || version < "1.8.0") {
  [07:16:40.973]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.973]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.973]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.973]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.973]                         "release", "version")], collapse = " "), 
  [07:16:40.973]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.973]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.973]                       info)
  [07:16:40.973]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.973]                     if (!has_future) {
  [07:16:40.973]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.973]                         info)
  [07:16:40.973]                     }
  [07:16:40.973]                     else {
  [07:16:40.973]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.973]                         info, version)
  [07:16:40.973]                     }
  [07:16:40.973]                     base::stop(msg)
  [07:16:40.973]                   }
  [07:16:40.973]                 })
  [07:16:40.973]             }
  [07:16:40.973]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.973]         }
  [07:16:40.973]     }
  [07:16:40.973]     if (base::is.na(NA)) {
  [07:16:40.973]     }
  [07:16:40.973]     else {
  [07:16:40.973]         if (NA) {
  [07:16:40.973]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.973]                 open = "w")
  [07:16:40.973]         }
  [07:16:40.973]         else {
  [07:16:40.973]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.973]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.973]         }
  [07:16:40.973]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.973]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.973]             base::sink(type = "output", split = FALSE)
  [07:16:40.973]             base::close(...future.stdout)
  [07:16:40.973]         }, add = TRUE)
  [07:16:40.973]     }
  [07:16:40.973]     ...future.frame <- base::sys.nframe()
  [07:16:40.973]     ...future.conditions <- base::list()
  [07:16:40.973]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.973]     ...future.result <- base::tryCatch({
  [07:16:40.973]         base::withCallingHandlers({
  [07:16:40.973]             ...future.value <- base::withVisible(base::local({
  [07:16:40.973]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.973]             }))
  [07:16:40.973]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.973]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.973]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.973]                 version = "1.8")
  [07:16:40.973]         }, condition = base::local({
  [07:16:40.973]             c <- base::c
  [07:16:40.973]             inherits <- base::inherits
  [07:16:40.973]             invokeRestart <- base::invokeRestart
  [07:16:40.973]             length <- base::length
  [07:16:40.973]             list <- base::list
  [07:16:40.973]             seq.int <- base::seq.int
  [07:16:40.973]             signalCondition <- base::signalCondition
  [07:16:40.973]             sys.calls <- base::sys.calls
  [07:16:40.973]             Sys.time <- base::Sys.time
  [07:16:40.973]             `[[` <- base::`[[`
  [07:16:40.973]             `+` <- base::`+`
  [07:16:40.973]             `<<-` <- base::`<<-`
  [07:16:40.973]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.973]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.973]                   3L)]
  [07:16:40.973]             }
  [07:16:40.973]             function(cond) {
  [07:16:40.973]                 if (inherits(cond, "error")) {
  [07:16:40.973]                   sessionInformation <- function() {
  [07:16:40.973]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.973]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.973]                       search = base::search(), system = base::Sys.info())
  [07:16:40.973]                   }
  [07:16:40.973]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.973]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.973]                     cond$call), session = sessionInformation(), 
  [07:16:40.973]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.973]                   signalCondition(cond)
  [07:16:40.973]                 }
  [07:16:40.973]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.973]                 ))) {
  [07:16:40.973]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.973]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.973]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.973]                   if (!signal) {
  [07:16:40.973]                     muffleCondition <- function (cond) 
  [07:16:40.973]                     {
  [07:16:40.973]                       inherits <- base::inherits
  [07:16:40.973]                       invokeRestart <- base::invokeRestart
  [07:16:40.973]                       muffled <- FALSE
  [07:16:40.973]                       if (inherits(cond, "message")) {
  [07:16:40.973]                         invokeRestart("muffleMessage")
  [07:16:40.973]                         muffled <- TRUE
  [07:16:40.973]                       }
  [07:16:40.973]                       else if (inherits(cond, "warning")) {
  [07:16:40.973]                         invokeRestart("muffleWarning")
  [07:16:40.973]                         muffled <- TRUE
  [07:16:40.973]                       }
  [07:16:40.973]                       else if (inherits(cond, "condition")) {
  [07:16:40.973]                         computeRestarts <- base::computeRestarts
  [07:16:40.973]                         grepl <- base::grepl
  [07:16:40.973]                         is.null <- base::is.null
  [07:16:40.973]                         restarts <- computeRestarts(cond)
  [07:16:40.973]                         for (restart in restarts) {
  [07:16:40.973]                           name <- restart$name
  [07:16:40.973]                           if (is.null(name)) 
  [07:16:40.973]                             next
  [07:16:40.973]                           if (!grepl("^muffle", name)) 
  [07:16:40.973]                             next
  [07:16:40.973]                           invokeRestart(restart)
  [07:16:40.973]                           muffled <- TRUE
  [07:16:40.973]                           break
  [07:16:40.973]                         }
  [07:16:40.973]                       }
  [07:16:40.973]                       invisible(muffled)
  [07:16:40.973]                     }
  [07:16:40.973]                     muffleCondition(cond)
  [07:16:40.973]                   }
  [07:16:40.973]                 }
  [07:16:40.973]             }
  [07:16:40.973]         }))
  [07:16:40.973]     }, error = function(ex) {
  [07:16:40.973]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.973]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.973]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.973]     }, finally = {
  [07:16:40.973]         {
  [07:16:40.973]             NULL
  [07:16:40.973]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.973]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.973]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.973]                 label = NULL, ...) 
  [07:16:40.973]             {
  [07:16:40.973]                 if (substitute) 
  [07:16:40.973]                   expr <- substitute(expr)
  [07:16:40.973]                 local <- as.logical(local)
  [07:16:40.973]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.973]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.973]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.973]                   label = label, ...)
  [07:16:40.973]                 if (!future$lazy) 
  [07:16:40.973]                   future <- run(future)
  [07:16:40.973]                 invisible(future)
  [07:16:40.973]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.973]         }
  [07:16:40.973]         base::options(...future.oldOptions)
  [07:16:40.973]     })
  [07:16:40.973]     Sys.time
  [07:16:40.973]     if (base::is.na(NA)) {
  [07:16:40.973]     }
  [07:16:40.973]     else {
  [07:16:40.973]         base::sink(type = "output", split = FALSE)
  [07:16:40.973]         if (NA) {
  [07:16:40.973]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.973]         }
  [07:16:40.973]         else {
  [07:16:40.973]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.973]         }
  [07:16:40.973]         base::close(...future.stdout)
  [07:16:40.973]         ...future.stdout <- NULL
  [07:16:40.973]     }
  [07:16:40.973]     ...future.result$conditions <- ...future.conditions
  [07:16:40.973]     ...future.result
  [07:16:40.973] }
  [07:16:40.978] plan(): Setting new future strategy stack:
  [07:16:40.979] List of future strategies:
  [07:16:40.979] 1. sequential:
  [07:16:40.979]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.979]    - tweaked: FALSE
  [07:16:40.979]    - call: NULL
  [07:16:40.981] plan(): nbrOfWorkers() = 1
  [07:16:40.983] Packages needed by the future expression (n = 0): <none>
  [07:16:40.986] Packages needed by future strategies (n = 0): <none>
  [07:16:40.991] {
  [07:16:40.991]     {
  [07:16:40.991]         ...future.startTime <- base::Sys.time()
  [07:16:40.991]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:40.991]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:40.991]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:40.991]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:40.991]             future.resolve.recursive = NULL, width = 80L)
  [07:16:40.991]         {
  [07:16:40.991]             {
  [07:16:40.991]                 base::local({
  [07:16:40.991]                   has_future <- base::requireNamespace("future", 
  [07:16:40.991]                     quietly = TRUE)
  [07:16:40.991]                   version <- if (has_future) 
  [07:16:40.991]                     utils::packageVersion("future")
  [07:16:40.991]                   else NULL
  [07:16:40.991]                   if (!has_future || version < "1.8.0") {
  [07:16:40.991]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:40.991]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:40.991]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:40.991]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:40.991]                         "release", "version")], collapse = " "), 
  [07:16:40.991]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:40.991]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:40.991]                       info)
  [07:16:40.991]                     info <- base::paste(info, collapse = "; ")
  [07:16:40.991]                     if (!has_future) {
  [07:16:40.991]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:40.991]                         info)
  [07:16:40.991]                     }
  [07:16:40.991]                     else {
  [07:16:40.991]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:40.991]                         info, version)
  [07:16:40.991]                     }
  [07:16:40.991]                     base::stop(msg)
  [07:16:40.991]                   }
  [07:16:40.991]                 })
  [07:16:40.991]             }
  [07:16:40.991]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:40.991]         }
  [07:16:40.991]     }
  [07:16:40.991]     if (base::is.na(NA)) {
  [07:16:40.991]     }
  [07:16:40.991]     else {
  [07:16:40.991]         if (NA) {
  [07:16:40.991]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:40.991]                 open = "w")
  [07:16:40.991]         }
  [07:16:40.991]         else {
  [07:16:40.991]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:40.991]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:40.991]         }
  [07:16:40.991]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:40.991]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:40.991]             base::sink(type = "output", split = FALSE)
  [07:16:40.991]             base::close(...future.stdout)
  [07:16:40.991]         }, add = TRUE)
  [07:16:40.991]     }
  [07:16:40.991]     ...future.frame <- base::sys.nframe()
  [07:16:40.991]     ...future.conditions <- base::list()
  [07:16:40.991]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:40.991]     ...future.result <- base::tryCatch({
  [07:16:40.991]         base::withCallingHandlers({
  [07:16:40.991]             ...future.value <- base::withVisible(base::local({
  [07:16:40.991]                 x[[i - 2]] + x[[i - 1]]
  [07:16:40.991]             }))
  [07:16:40.991]             future::FutureResult(value = ...future.value$value, 
  [07:16:40.991]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.991]                   ...future.rng), started = ...future.startTime, 
  [07:16:40.991]                 version = "1.8")
  [07:16:40.991]         }, condition = base::local({
  [07:16:40.991]             c <- base::c
  [07:16:40.991]             inherits <- base::inherits
  [07:16:40.991]             invokeRestart <- base::invokeRestart
  [07:16:40.991]             length <- base::length
  [07:16:40.991]             list <- base::list
  [07:16:40.991]             seq.int <- base::seq.int
  [07:16:40.991]             signalCondition <- base::signalCondition
  [07:16:40.991]             sys.calls <- base::sys.calls
  [07:16:40.991]             Sys.time <- base::Sys.time
  [07:16:40.991]             `[[` <- base::`[[`
  [07:16:40.991]             `+` <- base::`+`
  [07:16:40.991]             `<<-` <- base::`<<-`
  [07:16:40.991]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:40.991]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:40.991]                   3L)]
  [07:16:40.991]             }
  [07:16:40.991]             function(cond) {
  [07:16:40.991]                 if (inherits(cond, "error")) {
  [07:16:40.991]                   sessionInformation <- function() {
  [07:16:40.991]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:40.991]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:40.991]                       search = base::search(), system = base::Sys.info())
  [07:16:40.991]                   }
  [07:16:40.991]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.991]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:40.991]                     cond$call), session = sessionInformation(), 
  [07:16:40.991]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:40.991]                   signalCondition(cond)
  [07:16:40.991]                 }
  [07:16:40.991]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:40.991]                 ))) {
  [07:16:40.991]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:40.991]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:40.991]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:40.991]                   if (!signal) {
  [07:16:40.991]                     muffleCondition <- function (cond) 
  [07:16:40.991]                     {
  [07:16:40.991]                       inherits <- base::inherits
  [07:16:40.991]                       invokeRestart <- base::invokeRestart
  [07:16:40.991]                       muffled <- FALSE
  [07:16:40.991]                       if (inherits(cond, "message")) {
  [07:16:40.991]                         invokeRestart("muffleMessage")
  [07:16:40.991]                         muffled <- TRUE
  [07:16:40.991]                       }
  [07:16:40.991]                       else if (inherits(cond, "warning")) {
  [07:16:40.991]                         invokeRestart("muffleWarning")
  [07:16:40.991]                         muffled <- TRUE
  [07:16:40.991]                       }
  [07:16:40.991]                       else if (inherits(cond, "condition")) {
  [07:16:40.991]                         computeRestarts <- base::computeRestarts
  [07:16:40.991]                         grepl <- base::grepl
  [07:16:40.991]                         is.null <- base::is.null
  [07:16:40.991]                         restarts <- computeRestarts(cond)
  [07:16:40.991]                         for (restart in restarts) {
  [07:16:40.991]                           name <- restart$name
  [07:16:40.991]                           if (is.null(name)) 
  [07:16:40.991]                             next
  [07:16:40.991]                           if (!grepl("^muffle", name)) 
  [07:16:40.991]                             next
  [07:16:40.991]                           invokeRestart(restart)
  [07:16:40.991]                           muffled <- TRUE
  [07:16:40.991]                           break
  [07:16:40.991]                         }
  [07:16:40.991]                       }
  [07:16:40.991]                       invisible(muffled)
  [07:16:40.991]                     }
  [07:16:40.991]                     muffleCondition(cond)
  [07:16:40.991]                   }
  [07:16:40.991]                 }
  [07:16:40.991]             }
  [07:16:40.991]         }))
  [07:16:40.991]     }, error = function(ex) {
  [07:16:40.991]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:40.991]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:40.991]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:40.991]     }, finally = {
  [07:16:40.991]         {
  [07:16:40.991]             NULL
  [07:16:40.991]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:40.991]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:40.991]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:40.991]                 label = NULL, ...) 
  [07:16:40.991]             {
  [07:16:40.991]                 if (substitute) 
  [07:16:40.991]                   expr <- substitute(expr)
  [07:16:40.991]                 local <- as.logical(local)
  [07:16:40.991]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:40.991]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:40.991]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:40.991]                   label = label, ...)
  [07:16:40.991]                 if (!future$lazy) 
  [07:16:40.991]                   future <- run(future)
  [07:16:40.991]                 invisible(future)
  [07:16:40.991]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:40.991]         }
  [07:16:40.991]         base::options(...future.oldOptions)
  [07:16:40.991]     })
  [07:16:40.991]     Sys.time
  [07:16:40.991]     if (base::is.na(NA)) {
  [07:16:40.991]     }
  [07:16:40.991]     else {
  [07:16:40.991]         base::sink(type = "output", split = FALSE)
  [07:16:40.991]         if (NA) {
  [07:16:40.991]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:40.991]         }
  [07:16:40.991]         else {
  [07:16:40.991]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:40.991]         }
  [07:16:40.991]         base::close(...future.stdout)
  [07:16:40.991]         ...future.stdout <- NULL
  [07:16:40.991]     }
  [07:16:40.991]     ...future.result$conditions <- ...future.conditions
  [07:16:40.991]     ...future.result
  [07:16:40.991] }
  [07:16:40.995] plan(): Setting new future strategy stack:
  [07:16:40.996] List of future strategies:
  [07:16:40.996] 1. sequential:
  [07:16:40.996]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:40.996]    - tweaked: FALSE
  [07:16:40.996]    - call: NULL
  [07:16:40.998] plan(): nbrOfWorkers() = 1
  [07:16:41.000] Packages needed by the future expression (n = 0): <none>
  [07:16:41.002] Packages needed by future strategies (n = 0): <none>
  [07:16:41.006] {
  [07:16:41.006]     {
  [07:16:41.006]         ...future.startTime <- base::Sys.time()
  [07:16:41.006]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.006]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.006]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.006]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.006]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.006]         {
  [07:16:41.006]             {
  [07:16:41.006]                 base::local({
  [07:16:41.006]                   has_future <- base::requireNamespace("future", 
  [07:16:41.006]                     quietly = TRUE)
  [07:16:41.006]                   version <- if (has_future) 
  [07:16:41.006]                     utils::packageVersion("future")
  [07:16:41.006]                   else NULL
  [07:16:41.006]                   if (!has_future || version < "1.8.0") {
  [07:16:41.006]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.006]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.006]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.006]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.006]                         "release", "version")], collapse = " "), 
  [07:16:41.006]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.006]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.006]                       info)
  [07:16:41.006]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.006]                     if (!has_future) {
  [07:16:41.006]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.006]                         info)
  [07:16:41.006]                     }
  [07:16:41.006]                     else {
  [07:16:41.006]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.006]                         info, version)
  [07:16:41.006]                     }
  [07:16:41.006]                     base::stop(msg)
  [07:16:41.006]                   }
  [07:16:41.006]                 })
  [07:16:41.006]             }
  [07:16:41.006]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.006]         }
  [07:16:41.006]     }
  [07:16:41.006]     if (base::is.na(NA)) {
  [07:16:41.006]     }
  [07:16:41.006]     else {
  [07:16:41.006]         if (NA) {
  [07:16:41.006]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.006]                 open = "w")
  [07:16:41.006]         }
  [07:16:41.006]         else {
  [07:16:41.006]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.006]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.006]         }
  [07:16:41.006]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.006]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.006]             base::sink(type = "output", split = FALSE)
  [07:16:41.006]             base::close(...future.stdout)
  [07:16:41.006]         }, add = TRUE)
  [07:16:41.006]     }
  [07:16:41.006]     ...future.frame <- base::sys.nframe()
  [07:16:41.006]     ...future.conditions <- base::list()
  [07:16:41.006]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.006]     ...future.result <- base::tryCatch({
  [07:16:41.006]         base::withCallingHandlers({
  [07:16:41.006]             ...future.value <- base::withVisible(base::local({
  [07:16:41.006]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.006]             }))
  [07:16:41.006]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.006]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.006]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.006]                 version = "1.8")
  [07:16:41.006]         }, condition = base::local({
  [07:16:41.006]             c <- base::c
  [07:16:41.006]             inherits <- base::inherits
  [07:16:41.006]             invokeRestart <- base::invokeRestart
  [07:16:41.006]             length <- base::length
  [07:16:41.006]             list <- base::list
  [07:16:41.006]             seq.int <- base::seq.int
  [07:16:41.006]             signalCondition <- base::signalCondition
  [07:16:41.006]             sys.calls <- base::sys.calls
  [07:16:41.006]             Sys.time <- base::Sys.time
  [07:16:41.006]             `[[` <- base::`[[`
  [07:16:41.006]             `+` <- base::`+`
  [07:16:41.006]             `<<-` <- base::`<<-`
  [07:16:41.006]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.006]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.006]                   3L)]
  [07:16:41.006]             }
  [07:16:41.006]             function(cond) {
  [07:16:41.006]                 if (inherits(cond, "error")) {
  [07:16:41.006]                   sessionInformation <- function() {
  [07:16:41.006]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.006]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.006]                       search = base::search(), system = base::Sys.info())
  [07:16:41.006]                   }
  [07:16:41.006]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.006]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.006]                     cond$call), session = sessionInformation(), 
  [07:16:41.006]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.006]                   signalCondition(cond)
  [07:16:41.006]                 }
  [07:16:41.006]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.006]                 ))) {
  [07:16:41.006]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.006]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.006]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.006]                   if (!signal) {
  [07:16:41.006]                     muffleCondition <- function (cond) 
  [07:16:41.006]                     {
  [07:16:41.006]                       inherits <- base::inherits
  [07:16:41.006]                       invokeRestart <- base::invokeRestart
  [07:16:41.006]                       muffled <- FALSE
  [07:16:41.006]                       if (inherits(cond, "message")) {
  [07:16:41.006]                         invokeRestart("muffleMessage")
  [07:16:41.006]                         muffled <- TRUE
  [07:16:41.006]                       }
  [07:16:41.006]                       else if (inherits(cond, "warning")) {
  [07:16:41.006]                         invokeRestart("muffleWarning")
  [07:16:41.006]                         muffled <- TRUE
  [07:16:41.006]                       }
  [07:16:41.006]                       else if (inherits(cond, "condition")) {
  [07:16:41.006]                         computeRestarts <- base::computeRestarts
  [07:16:41.006]                         grepl <- base::grepl
  [07:16:41.006]                         is.null <- base::is.null
  [07:16:41.006]                         restarts <- computeRestarts(cond)
  [07:16:41.006]                         for (restart in restarts) {
  [07:16:41.006]                           name <- restart$name
  [07:16:41.006]                           if (is.null(name)) 
  [07:16:41.006]                             next
  [07:16:41.006]                           if (!grepl("^muffle", name)) 
  [07:16:41.006]                             next
  [07:16:41.006]                           invokeRestart(restart)
  [07:16:41.006]                           muffled <- TRUE
  [07:16:41.006]                           break
  [07:16:41.006]                         }
  [07:16:41.006]                       }
  [07:16:41.006]                       invisible(muffled)
  [07:16:41.006]                     }
  [07:16:41.006]                     muffleCondition(cond)
  [07:16:41.006]                   }
  [07:16:41.006]                 }
  [07:16:41.006]             }
  [07:16:41.006]         }))
  [07:16:41.006]     }, error = function(ex) {
  [07:16:41.006]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.006]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.006]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.006]     }, finally = {
  [07:16:41.006]         {
  [07:16:41.006]             NULL
  [07:16:41.006]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.006]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.006]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.006]                 label = NULL, ...) 
  [07:16:41.006]             {
  [07:16:41.006]                 if (substitute) 
  [07:16:41.006]                   expr <- substitute(expr)
  [07:16:41.006]                 local <- as.logical(local)
  [07:16:41.006]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.006]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.006]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.006]                   label = label, ...)
  [07:16:41.006]                 if (!future$lazy) 
  [07:16:41.006]                   future <- run(future)
  [07:16:41.006]                 invisible(future)
  [07:16:41.006]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.006]         }
  [07:16:41.006]         base::options(...future.oldOptions)
  [07:16:41.006]     })
  [07:16:41.006]     Sys.time
  [07:16:41.006]     if (base::is.na(NA)) {
  [07:16:41.006]     }
  [07:16:41.006]     else {
  [07:16:41.006]         base::sink(type = "output", split = FALSE)
  [07:16:41.006]         if (NA) {
  [07:16:41.006]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.006]         }
  [07:16:41.006]         else {
  [07:16:41.006]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.006]         }
  [07:16:41.006]         base::close(...future.stdout)
  [07:16:41.006]         ...future.stdout <- NULL
  [07:16:41.006]     }
  [07:16:41.006]     ...future.result$conditions <- ...future.conditions
  [07:16:41.006]     ...future.result
  [07:16:41.006] }
  [07:16:41.010] plan(): Setting new future strategy stack:
  [07:16:41.012] List of future strategies:
  [07:16:41.012] 1. sequential:
  [07:16:41.012]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.012]    - tweaked: FALSE
  [07:16:41.012]    - call: NULL
  [07:16:41.013] plan(): nbrOfWorkers() = 1
  [07:16:41.016] Packages needed by the future expression (n = 0): <none>
  [07:16:41.017] Packages needed by future strategies (n = 0): <none>
  [07:16:41.021] {
  [07:16:41.021]     {
  [07:16:41.021]         ...future.startTime <- base::Sys.time()
  [07:16:41.021]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.021]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.021]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.021]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.021]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.021]         {
  [07:16:41.021]             {
  [07:16:41.021]                 base::local({
  [07:16:41.021]                   has_future <- base::requireNamespace("future", 
  [07:16:41.021]                     quietly = TRUE)
  [07:16:41.021]                   version <- if (has_future) 
  [07:16:41.021]                     utils::packageVersion("future")
  [07:16:41.021]                   else NULL
  [07:16:41.021]                   if (!has_future || version < "1.8.0") {
  [07:16:41.021]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.021]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.021]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.021]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.021]                         "release", "version")], collapse = " "), 
  [07:16:41.021]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.021]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.021]                       info)
  [07:16:41.021]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.021]                     if (!has_future) {
  [07:16:41.021]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.021]                         info)
  [07:16:41.021]                     }
  [07:16:41.021]                     else {
  [07:16:41.021]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.021]                         info, version)
  [07:16:41.021]                     }
  [07:16:41.021]                     base::stop(msg)
  [07:16:41.021]                   }
  [07:16:41.021]                 })
  [07:16:41.021]             }
  [07:16:41.021]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.021]         }
  [07:16:41.021]     }
  [07:16:41.021]     if (base::is.na(NA)) {
  [07:16:41.021]     }
  [07:16:41.021]     else {
  [07:16:41.021]         if (NA) {
  [07:16:41.021]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.021]                 open = "w")
  [07:16:41.021]         }
  [07:16:41.021]         else {
  [07:16:41.021]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.021]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.021]         }
  [07:16:41.021]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.021]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.021]             base::sink(type = "output", split = FALSE)
  [07:16:41.021]             base::close(...future.stdout)
  [07:16:41.021]         }, add = TRUE)
  [07:16:41.021]     }
  [07:16:41.021]     ...future.frame <- base::sys.nframe()
  [07:16:41.021]     ...future.conditions <- base::list()
  [07:16:41.021]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.021]     ...future.result <- base::tryCatch({
  [07:16:41.021]         base::withCallingHandlers({
  [07:16:41.021]             ...future.value <- base::withVisible(base::local({
  [07:16:41.021]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.021]             }))
  [07:16:41.021]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.021]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.021]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.021]                 version = "1.8")
  [07:16:41.021]         }, condition = base::local({
  [07:16:41.021]             c <- base::c
  [07:16:41.021]             inherits <- base::inherits
  [07:16:41.021]             invokeRestart <- base::invokeRestart
  [07:16:41.021]             length <- base::length
  [07:16:41.021]             list <- base::list
  [07:16:41.021]             seq.int <- base::seq.int
  [07:16:41.021]             signalCondition <- base::signalCondition
  [07:16:41.021]             sys.calls <- base::sys.calls
  [07:16:41.021]             Sys.time <- base::Sys.time
  [07:16:41.021]             `[[` <- base::`[[`
  [07:16:41.021]             `+` <- base::`+`
  [07:16:41.021]             `<<-` <- base::`<<-`
  [07:16:41.021]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.021]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.021]                   3L)]
  [07:16:41.021]             }
  [07:16:41.021]             function(cond) {
  [07:16:41.021]                 if (inherits(cond, "error")) {
  [07:16:41.021]                   sessionInformation <- function() {
  [07:16:41.021]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.021]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.021]                       search = base::search(), system = base::Sys.info())
  [07:16:41.021]                   }
  [07:16:41.021]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.021]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.021]                     cond$call), session = sessionInformation(), 
  [07:16:41.021]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.021]                   signalCondition(cond)
  [07:16:41.021]                 }
  [07:16:41.021]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.021]                 ))) {
  [07:16:41.021]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.021]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.021]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.021]                   if (!signal) {
  [07:16:41.021]                     muffleCondition <- function (cond) 
  [07:16:41.021]                     {
  [07:16:41.021]                       inherits <- base::inherits
  [07:16:41.021]                       invokeRestart <- base::invokeRestart
  [07:16:41.021]                       muffled <- FALSE
  [07:16:41.021]                       if (inherits(cond, "message")) {
  [07:16:41.021]                         invokeRestart("muffleMessage")
  [07:16:41.021]                         muffled <- TRUE
  [07:16:41.021]                       }
  [07:16:41.021]                       else if (inherits(cond, "warning")) {
  [07:16:41.021]                         invokeRestart("muffleWarning")
  [07:16:41.021]                         muffled <- TRUE
  [07:16:41.021]                       }
  [07:16:41.021]                       else if (inherits(cond, "condition")) {
  [07:16:41.021]                         computeRestarts <- base::computeRestarts
  [07:16:41.021]                         grepl <- base::grepl
  [07:16:41.021]                         is.null <- base::is.null
  [07:16:41.021]                         restarts <- computeRestarts(cond)
  [07:16:41.021]                         for (restart in restarts) {
  [07:16:41.021]                           name <- restart$name
  [07:16:41.021]                           if (is.null(name)) 
  [07:16:41.021]                             next
  [07:16:41.021]                           if (!grepl("^muffle", name)) 
  [07:16:41.021]                             next
  [07:16:41.021]                           invokeRestart(restart)
  [07:16:41.021]                           muffled <- TRUE
  [07:16:41.021]                           break
  [07:16:41.021]                         }
  [07:16:41.021]                       }
  [07:16:41.021]                       invisible(muffled)
  [07:16:41.021]                     }
  [07:16:41.021]                     muffleCondition(cond)
  [07:16:41.021]                   }
  [07:16:41.021]                 }
  [07:16:41.021]             }
  [07:16:41.021]         }))
  [07:16:41.021]     }, error = function(ex) {
  [07:16:41.021]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.021]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.021]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.021]     }, finally = {
  [07:16:41.021]         {
  [07:16:41.021]             NULL
  [07:16:41.021]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.021]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.021]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.021]                 label = NULL, ...) 
  [07:16:41.021]             {
  [07:16:41.021]                 if (substitute) 
  [07:16:41.021]                   expr <- substitute(expr)
  [07:16:41.021]                 local <- as.logical(local)
  [07:16:41.021]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.021]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.021]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.021]                   label = label, ...)
  [07:16:41.021]                 if (!future$lazy) 
  [07:16:41.021]                   future <- run(future)
  [07:16:41.021]                 invisible(future)
  [07:16:41.021]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.021]         }
  [07:16:41.021]         base::options(...future.oldOptions)
  [07:16:41.021]     })
  [07:16:41.021]     Sys.time
  [07:16:41.021]     if (base::is.na(NA)) {
  [07:16:41.021]     }
  [07:16:41.021]     else {
  [07:16:41.021]         base::sink(type = "output", split = FALSE)
  [07:16:41.021]         if (NA) {
  [07:16:41.021]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.021]         }
  [07:16:41.021]         else {
  [07:16:41.021]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.021]         }
  [07:16:41.021]         base::close(...future.stdout)
  [07:16:41.021]         ...future.stdout <- NULL
  [07:16:41.021]     }
  [07:16:41.021]     ...future.result$conditions <- ...future.conditions
  [07:16:41.021]     ...future.result
  [07:16:41.021] }
  [07:16:41.026] plan(): Setting new future strategy stack:
  [07:16:41.027] List of future strategies:
  [07:16:41.027] 1. sequential:
  [07:16:41.027]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.027]    - tweaked: FALSE
  [07:16:41.027]    - call: NULL
  [07:16:41.029] plan(): nbrOfWorkers() = 1
  [07:16:41.032] Packages needed by the future expression (n = 0): <none>
  [07:16:41.033] Packages needed by future strategies (n = 0): <none>
  [07:16:41.037] {
  [07:16:41.037]     {
  [07:16:41.037]         ...future.startTime <- base::Sys.time()
  [07:16:41.037]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.037]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.037]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.037]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.037]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.037]         {
  [07:16:41.037]             {
  [07:16:41.037]                 base::local({
  [07:16:41.037]                   has_future <- base::requireNamespace("future", 
  [07:16:41.037]                     quietly = TRUE)
  [07:16:41.037]                   version <- if (has_future) 
  [07:16:41.037]                     utils::packageVersion("future")
  [07:16:41.037]                   else NULL
  [07:16:41.037]                   if (!has_future || version < "1.8.0") {
  [07:16:41.037]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.037]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.037]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.037]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.037]                         "release", "version")], collapse = " "), 
  [07:16:41.037]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.037]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.037]                       info)
  [07:16:41.037]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.037]                     if (!has_future) {
  [07:16:41.037]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.037]                         info)
  [07:16:41.037]                     }
  [07:16:41.037]                     else {
  [07:16:41.037]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.037]                         info, version)
  [07:16:41.037]                     }
  [07:16:41.037]                     base::stop(msg)
  [07:16:41.037]                   }
  [07:16:41.037]                 })
  [07:16:41.037]             }
  [07:16:41.037]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.037]         }
  [07:16:41.037]     }
  [07:16:41.037]     if (base::is.na(NA)) {
  [07:16:41.037]     }
  [07:16:41.037]     else {
  [07:16:41.037]         if (NA) {
  [07:16:41.037]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.037]                 open = "w")
  [07:16:41.037]         }
  [07:16:41.037]         else {
  [07:16:41.037]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.037]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.037]         }
  [07:16:41.037]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.037]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.037]             base::sink(type = "output", split = FALSE)
  [07:16:41.037]             base::close(...future.stdout)
  [07:16:41.037]         }, add = TRUE)
  [07:16:41.037]     }
  [07:16:41.037]     ...future.frame <- base::sys.nframe()
  [07:16:41.037]     ...future.conditions <- base::list()
  [07:16:41.037]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.037]     ...future.result <- base::tryCatch({
  [07:16:41.037]         base::withCallingHandlers({
  [07:16:41.037]             ...future.value <- base::withVisible(base::local({
  [07:16:41.037]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.037]             }))
  [07:16:41.037]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.037]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.037]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.037]                 version = "1.8")
  [07:16:41.037]         }, condition = base::local({
  [07:16:41.037]             c <- base::c
  [07:16:41.037]             inherits <- base::inherits
  [07:16:41.037]             invokeRestart <- base::invokeRestart
  [07:16:41.037]             length <- base::length
  [07:16:41.037]             list <- base::list
  [07:16:41.037]             seq.int <- base::seq.int
  [07:16:41.037]             signalCondition <- base::signalCondition
  [07:16:41.037]             sys.calls <- base::sys.calls
  [07:16:41.037]             Sys.time <- base::Sys.time
  [07:16:41.037]             `[[` <- base::`[[`
  [07:16:41.037]             `+` <- base::`+`
  [07:16:41.037]             `<<-` <- base::`<<-`
  [07:16:41.037]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.037]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.037]                   3L)]
  [07:16:41.037]             }
  [07:16:41.037]             function(cond) {
  [07:16:41.037]                 if (inherits(cond, "error")) {
  [07:16:41.037]                   sessionInformation <- function() {
  [07:16:41.037]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.037]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.037]                       search = base::search(), system = base::Sys.info())
  [07:16:41.037]                   }
  [07:16:41.037]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.037]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.037]                     cond$call), session = sessionInformation(), 
  [07:16:41.037]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.037]                   signalCondition(cond)
  [07:16:41.037]                 }
  [07:16:41.037]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.037]                 ))) {
  [07:16:41.037]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.037]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.037]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.037]                   if (!signal) {
  [07:16:41.037]                     muffleCondition <- function (cond) 
  [07:16:41.037]                     {
  [07:16:41.037]                       inherits <- base::inherits
  [07:16:41.037]                       invokeRestart <- base::invokeRestart
  [07:16:41.037]                       muffled <- FALSE
  [07:16:41.037]                       if (inherits(cond, "message")) {
  [07:16:41.037]                         invokeRestart("muffleMessage")
  [07:16:41.037]                         muffled <- TRUE
  [07:16:41.037]                       }
  [07:16:41.037]                       else if (inherits(cond, "warning")) {
  [07:16:41.037]                         invokeRestart("muffleWarning")
  [07:16:41.037]                         muffled <- TRUE
  [07:16:41.037]                       }
  [07:16:41.037]                       else if (inherits(cond, "condition")) {
  [07:16:41.037]                         computeRestarts <- base::computeRestarts
  [07:16:41.037]                         grepl <- base::grepl
  [07:16:41.037]                         is.null <- base::is.null
  [07:16:41.037]                         restarts <- computeRestarts(cond)
  [07:16:41.037]                         for (restart in restarts) {
  [07:16:41.037]                           name <- restart$name
  [07:16:41.037]                           if (is.null(name)) 
  [07:16:41.037]                             next
  [07:16:41.037]                           if (!grepl("^muffle", name)) 
  [07:16:41.037]                             next
  [07:16:41.037]                           invokeRestart(restart)
  [07:16:41.037]                           muffled <- TRUE
  [07:16:41.037]                           break
  [07:16:41.037]                         }
  [07:16:41.037]                       }
  [07:16:41.037]                       invisible(muffled)
  [07:16:41.037]                     }
  [07:16:41.037]                     muffleCondition(cond)
  [07:16:41.037]                   }
  [07:16:41.037]                 }
  [07:16:41.037]             }
  [07:16:41.037]         }))
  [07:16:41.037]     }, error = function(ex) {
  [07:16:41.037]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.037]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.037]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.037]     }, finally = {
  [07:16:41.037]         {
  [07:16:41.037]             NULL
  [07:16:41.037]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.037]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.037]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.037]                 label = NULL, ...) 
  [07:16:41.037]             {
  [07:16:41.037]                 if (substitute) 
  [07:16:41.037]                   expr <- substitute(expr)
  [07:16:41.037]                 local <- as.logical(local)
  [07:16:41.037]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.037]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.037]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.037]                   label = label, ...)
  [07:16:41.037]                 if (!future$lazy) 
  [07:16:41.037]                   future <- run(future)
  [07:16:41.037]                 invisible(future)
  [07:16:41.037]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.037]         }
  [07:16:41.037]         base::options(...future.oldOptions)
  [07:16:41.037]     })
  [07:16:41.037]     Sys.time
  [07:16:41.037]     if (base::is.na(NA)) {
  [07:16:41.037]     }
  [07:16:41.037]     else {
  [07:16:41.037]         base::sink(type = "output", split = FALSE)
  [07:16:41.037]         if (NA) {
  [07:16:41.037]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.037]         }
  [07:16:41.037]         else {
  [07:16:41.037]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.037]         }
  [07:16:41.037]         base::close(...future.stdout)
  [07:16:41.037]         ...future.stdout <- NULL
  [07:16:41.037]     }
  [07:16:41.037]     ...future.result$conditions <- ...future.conditions
  [07:16:41.037]     ...future.result
  [07:16:41.037] }
  [07:16:41.042] plan(): Setting new future strategy stack:
  [07:16:41.044] List of future strategies:
  [07:16:41.044] 1. sequential:
  [07:16:41.044]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.044]    - tweaked: FALSE
  [07:16:41.044]    - call: NULL
  [07:16:41.046] plan(): nbrOfWorkers() = 1
  [07:16:41.048] Packages needed by the future expression (n = 0): <none>
  [07:16:41.052] Packages needed by future strategies (n = 0): <none>
  [07:16:41.056] {
  [07:16:41.056]     {
  [07:16:41.056]         ...future.startTime <- base::Sys.time()
  [07:16:41.056]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.056]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.056]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.056]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.056]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.056]         {
  [07:16:41.056]             {
  [07:16:41.056]                 base::local({
  [07:16:41.056]                   has_future <- base::requireNamespace("future", 
  [07:16:41.056]                     quietly = TRUE)
  [07:16:41.056]                   version <- if (has_future) 
  [07:16:41.056]                     utils::packageVersion("future")
  [07:16:41.056]                   else NULL
  [07:16:41.056]                   if (!has_future || version < "1.8.0") {
  [07:16:41.056]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.056]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.056]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.056]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.056]                         "release", "version")], collapse = " "), 
  [07:16:41.056]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.056]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.056]                       info)
  [07:16:41.056]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.056]                     if (!has_future) {
  [07:16:41.056]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.056]                         info)
  [07:16:41.056]                     }
  [07:16:41.056]                     else {
  [07:16:41.056]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.056]                         info, version)
  [07:16:41.056]                     }
  [07:16:41.056]                     base::stop(msg)
  [07:16:41.056]                   }
  [07:16:41.056]                 })
  [07:16:41.056]             }
  [07:16:41.056]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.056]         }
  [07:16:41.056]     }
  [07:16:41.056]     if (base::is.na(NA)) {
  [07:16:41.056]     }
  [07:16:41.056]     else {
  [07:16:41.056]         if (NA) {
  [07:16:41.056]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.056]                 open = "w")
  [07:16:41.056]         }
  [07:16:41.056]         else {
  [07:16:41.056]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.056]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.056]         }
  [07:16:41.056]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.056]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.056]             base::sink(type = "output", split = FALSE)
  [07:16:41.056]             base::close(...future.stdout)
  [07:16:41.056]         }, add = TRUE)
  [07:16:41.056]     }
  [07:16:41.056]     ...future.frame <- base::sys.nframe()
  [07:16:41.056]     ...future.conditions <- base::list()
  [07:16:41.056]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.056]     ...future.result <- base::tryCatch({
  [07:16:41.056]         base::withCallingHandlers({
  [07:16:41.056]             ...future.value <- base::withVisible(base::local({
  [07:16:41.056]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.056]             }))
  [07:16:41.056]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.056]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.056]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.056]                 version = "1.8")
  [07:16:41.056]         }, condition = base::local({
  [07:16:41.056]             c <- base::c
  [07:16:41.056]             inherits <- base::inherits
  [07:16:41.056]             invokeRestart <- base::invokeRestart
  [07:16:41.056]             length <- base::length
  [07:16:41.056]             list <- base::list
  [07:16:41.056]             seq.int <- base::seq.int
  [07:16:41.056]             signalCondition <- base::signalCondition
  [07:16:41.056]             sys.calls <- base::sys.calls
  [07:16:41.056]             Sys.time <- base::Sys.time
  [07:16:41.056]             `[[` <- base::`[[`
  [07:16:41.056]             `+` <- base::`+`
  [07:16:41.056]             `<<-` <- base::`<<-`
  [07:16:41.056]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.056]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.056]                   3L)]
  [07:16:41.056]             }
  [07:16:41.056]             function(cond) {
  [07:16:41.056]                 if (inherits(cond, "error")) {
  [07:16:41.056]                   sessionInformation <- function() {
  [07:16:41.056]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.056]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.056]                       search = base::search(), system = base::Sys.info())
  [07:16:41.056]                   }
  [07:16:41.056]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.056]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.056]                     cond$call), session = sessionInformation(), 
  [07:16:41.056]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.056]                   signalCondition(cond)
  [07:16:41.056]                 }
  [07:16:41.056]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.056]                 ))) {
  [07:16:41.056]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.056]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.056]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.056]                   if (!signal) {
  [07:16:41.056]                     muffleCondition <- function (cond) 
  [07:16:41.056]                     {
  [07:16:41.056]                       inherits <- base::inherits
  [07:16:41.056]                       invokeRestart <- base::invokeRestart
  [07:16:41.056]                       muffled <- FALSE
  [07:16:41.056]                       if (inherits(cond, "message")) {
  [07:16:41.056]                         invokeRestart("muffleMessage")
  [07:16:41.056]                         muffled <- TRUE
  [07:16:41.056]                       }
  [07:16:41.056]                       else if (inherits(cond, "warning")) {
  [07:16:41.056]                         invokeRestart("muffleWarning")
  [07:16:41.056]                         muffled <- TRUE
  [07:16:41.056]                       }
  [07:16:41.056]                       else if (inherits(cond, "condition")) {
  [07:16:41.056]                         computeRestarts <- base::computeRestarts
  [07:16:41.056]                         grepl <- base::grepl
  [07:16:41.056]                         is.null <- base::is.null
  [07:16:41.056]                         restarts <- computeRestarts(cond)
  [07:16:41.056]                         for (restart in restarts) {
  [07:16:41.056]                           name <- restart$name
  [07:16:41.056]                           if (is.null(name)) 
  [07:16:41.056]                             next
  [07:16:41.056]                           if (!grepl("^muffle", name)) 
  [07:16:41.056]                             next
  [07:16:41.056]                           invokeRestart(restart)
  [07:16:41.056]                           muffled <- TRUE
  [07:16:41.056]                           break
  [07:16:41.056]                         }
  [07:16:41.056]                       }
  [07:16:41.056]                       invisible(muffled)
  [07:16:41.056]                     }
  [07:16:41.056]                     muffleCondition(cond)
  [07:16:41.056]                   }
  [07:16:41.056]                 }
  [07:16:41.056]             }
  [07:16:41.056]         }))
  [07:16:41.056]     }, error = function(ex) {
  [07:16:41.056]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.056]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.056]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.056]     }, finally = {
  [07:16:41.056]         {
  [07:16:41.056]             NULL
  [07:16:41.056]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.056]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.056]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.056]                 label = NULL, ...) 
  [07:16:41.056]             {
  [07:16:41.056]                 if (substitute) 
  [07:16:41.056]                   expr <- substitute(expr)
  [07:16:41.056]                 local <- as.logical(local)
  [07:16:41.056]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.056]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.056]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.056]                   label = label, ...)
  [07:16:41.056]                 if (!future$lazy) 
  [07:16:41.056]                   future <- run(future)
  [07:16:41.056]                 invisible(future)
  [07:16:41.056]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.056]         }
  [07:16:41.056]         base::options(...future.oldOptions)
  [07:16:41.056]     })
  [07:16:41.056]     Sys.time
  [07:16:41.056]     if (base::is.na(NA)) {
  [07:16:41.056]     }
  [07:16:41.056]     else {
  [07:16:41.056]         base::sink(type = "output", split = FALSE)
  [07:16:41.056]         if (NA) {
  [07:16:41.056]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.056]         }
  [07:16:41.056]         else {
  [07:16:41.056]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.056]         }
  [07:16:41.056]         base::close(...future.stdout)
  [07:16:41.056]         ...future.stdout <- NULL
  [07:16:41.056]     }
  [07:16:41.056]     ...future.result$conditions <- ...future.conditions
  [07:16:41.056]     ...future.result
  [07:16:41.056] }
  [07:16:41.061] plan(): Setting new future strategy stack:
  [07:16:41.063] List of future strategies:
  [07:16:41.063] 1. sequential:
  [07:16:41.063]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.063]    - tweaked: FALSE
  [07:16:41.063]    - call: NULL
  [07:16:41.065] plan(): nbrOfWorkers() = 1
  [07:16:41.067] Packages needed by the future expression (n = 0): <none>
  [07:16:41.069] Packages needed by future strategies (n = 0): <none>
  [07:16:41.074] {
  [07:16:41.074]     {
  [07:16:41.074]         ...future.startTime <- base::Sys.time()
  [07:16:41.074]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.074]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.074]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.074]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.074]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.074]         {
  [07:16:41.074]             {
  [07:16:41.074]                 base::local({
  [07:16:41.074]                   has_future <- base::requireNamespace("future", 
  [07:16:41.074]                     quietly = TRUE)
  [07:16:41.074]                   version <- if (has_future) 
  [07:16:41.074]                     utils::packageVersion("future")
  [07:16:41.074]                   else NULL
  [07:16:41.074]                   if (!has_future || version < "1.8.0") {
  [07:16:41.074]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.074]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.074]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.074]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.074]                         "release", "version")], collapse = " "), 
  [07:16:41.074]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.074]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.074]                       info)
  [07:16:41.074]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.074]                     if (!has_future) {
  [07:16:41.074]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.074]                         info)
  [07:16:41.074]                     }
  [07:16:41.074]                     else {
  [07:16:41.074]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.074]                         info, version)
  [07:16:41.074]                     }
  [07:16:41.074]                     base::stop(msg)
  [07:16:41.074]                   }
  [07:16:41.074]                 })
  [07:16:41.074]             }
  [07:16:41.074]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.074]         }
  [07:16:41.074]     }
  [07:16:41.074]     if (base::is.na(NA)) {
  [07:16:41.074]     }
  [07:16:41.074]     else {
  [07:16:41.074]         if (NA) {
  [07:16:41.074]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.074]                 open = "w")
  [07:16:41.074]         }
  [07:16:41.074]         else {
  [07:16:41.074]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.074]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.074]         }
  [07:16:41.074]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.074]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.074]             base::sink(type = "output", split = FALSE)
  [07:16:41.074]             base::close(...future.stdout)
  [07:16:41.074]         }, add = TRUE)
  [07:16:41.074]     }
  [07:16:41.074]     ...future.frame <- base::sys.nframe()
  [07:16:41.074]     ...future.conditions <- base::list()
  [07:16:41.074]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.074]     ...future.result <- base::tryCatch({
  [07:16:41.074]         base::withCallingHandlers({
  [07:16:41.074]             ...future.value <- base::withVisible(base::local({
  [07:16:41.074]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.074]             }))
  [07:16:41.074]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.074]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.074]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.074]                 version = "1.8")
  [07:16:41.074]         }, condition = base::local({
  [07:16:41.074]             c <- base::c
  [07:16:41.074]             inherits <- base::inherits
  [07:16:41.074]             invokeRestart <- base::invokeRestart
  [07:16:41.074]             length <- base::length
  [07:16:41.074]             list <- base::list
  [07:16:41.074]             seq.int <- base::seq.int
  [07:16:41.074]             signalCondition <- base::signalCondition
  [07:16:41.074]             sys.calls <- base::sys.calls
  [07:16:41.074]             Sys.time <- base::Sys.time
  [07:16:41.074]             `[[` <- base::`[[`
  [07:16:41.074]             `+` <- base::`+`
  [07:16:41.074]             `<<-` <- base::`<<-`
  [07:16:41.074]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.074]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.074]                   3L)]
  [07:16:41.074]             }
  [07:16:41.074]             function(cond) {
  [07:16:41.074]                 if (inherits(cond, "error")) {
  [07:16:41.074]                   sessionInformation <- function() {
  [07:16:41.074]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.074]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.074]                       search = base::search(), system = base::Sys.info())
  [07:16:41.074]                   }
  [07:16:41.074]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.074]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.074]                     cond$call), session = sessionInformation(), 
  [07:16:41.074]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.074]                   signalCondition(cond)
  [07:16:41.074]                 }
  [07:16:41.074]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.074]                 ))) {
  [07:16:41.074]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.074]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.074]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.074]                   if (!signal) {
  [07:16:41.074]                     muffleCondition <- function (cond) 
  [07:16:41.074]                     {
  [07:16:41.074]                       inherits <- base::inherits
  [07:16:41.074]                       invokeRestart <- base::invokeRestart
  [07:16:41.074]                       muffled <- FALSE
  [07:16:41.074]                       if (inherits(cond, "message")) {
  [07:16:41.074]                         invokeRestart("muffleMessage")
  [07:16:41.074]                         muffled <- TRUE
  [07:16:41.074]                       }
  [07:16:41.074]                       else if (inherits(cond, "warning")) {
  [07:16:41.074]                         invokeRestart("muffleWarning")
  [07:16:41.074]                         muffled <- TRUE
  [07:16:41.074]                       }
  [07:16:41.074]                       else if (inherits(cond, "condition")) {
  [07:16:41.074]                         computeRestarts <- base::computeRestarts
  [07:16:41.074]                         grepl <- base::grepl
  [07:16:41.074]                         is.null <- base::is.null
  [07:16:41.074]                         restarts <- computeRestarts(cond)
  [07:16:41.074]                         for (restart in restarts) {
  [07:16:41.074]                           name <- restart$name
  [07:16:41.074]                           if (is.null(name)) 
  [07:16:41.074]                             next
  [07:16:41.074]                           if (!grepl("^muffle", name)) 
  [07:16:41.074]                             next
  [07:16:41.074]                           invokeRestart(restart)
  [07:16:41.074]                           muffled <- TRUE
  [07:16:41.074]                           break
  [07:16:41.074]                         }
  [07:16:41.074]                       }
  [07:16:41.074]                       invisible(muffled)
  [07:16:41.074]                     }
  [07:16:41.074]                     muffleCondition(cond)
  [07:16:41.074]                   }
  [07:16:41.074]                 }
  [07:16:41.074]             }
  [07:16:41.074]         }))
  [07:16:41.074]     }, error = function(ex) {
  [07:16:41.074]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.074]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.074]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.074]     }, finally = {
  [07:16:41.074]         {
  [07:16:41.074]             NULL
  [07:16:41.074]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.074]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.074]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.074]                 label = NULL, ...) 
  [07:16:41.074]             {
  [07:16:41.074]                 if (substitute) 
  [07:16:41.074]                   expr <- substitute(expr)
  [07:16:41.074]                 local <- as.logical(local)
  [07:16:41.074]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.074]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.074]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.074]                   label = label, ...)
  [07:16:41.074]                 if (!future$lazy) 
  [07:16:41.074]                   future <- run(future)
  [07:16:41.074]                 invisible(future)
  [07:16:41.074]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.074]         }
  [07:16:41.074]         base::options(...future.oldOptions)
  [07:16:41.074]     })
  [07:16:41.074]     Sys.time
  [07:16:41.074]     if (base::is.na(NA)) {
  [07:16:41.074]     }
  [07:16:41.074]     else {
  [07:16:41.074]         base::sink(type = "output", split = FALSE)
  [07:16:41.074]         if (NA) {
  [07:16:41.074]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.074]         }
  [07:16:41.074]         else {
  [07:16:41.074]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.074]         }
  [07:16:41.074]         base::close(...future.stdout)
  [07:16:41.074]         ...future.stdout <- NULL
  [07:16:41.074]     }
  [07:16:41.074]     ...future.result$conditions <- ...future.conditions
  [07:16:41.074]     ...future.result
  [07:16:41.074] }
  [07:16:41.078] plan(): Setting new future strategy stack:
  [07:16:41.080] List of future strategies:
  [07:16:41.080] 1. sequential:
  [07:16:41.080]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.080]    - tweaked: FALSE
  [07:16:41.080]    - call: NULL
  [07:16:41.082] plan(): nbrOfWorkers() = 1
  [07:16:41.085] Packages needed by the future expression (n = 0): <none>
  [07:16:41.086] Packages needed by future strategies (n = 0): <none>
  [07:16:41.091] {
  [07:16:41.091]     {
  [07:16:41.091]         ...future.startTime <- base::Sys.time()
  [07:16:41.091]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.091]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.091]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.091]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.091]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.091]         {
  [07:16:41.091]             {
  [07:16:41.091]                 base::local({
  [07:16:41.091]                   has_future <- base::requireNamespace("future", 
  [07:16:41.091]                     quietly = TRUE)
  [07:16:41.091]                   version <- if (has_future) 
  [07:16:41.091]                     utils::packageVersion("future")
  [07:16:41.091]                   else NULL
  [07:16:41.091]                   if (!has_future || version < "1.8.0") {
  [07:16:41.091]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.091]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.091]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.091]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.091]                         "release", "version")], collapse = " "), 
  [07:16:41.091]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.091]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.091]                       info)
  [07:16:41.091]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.091]                     if (!has_future) {
  [07:16:41.091]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.091]                         info)
  [07:16:41.091]                     }
  [07:16:41.091]                     else {
  [07:16:41.091]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.091]                         info, version)
  [07:16:41.091]                     }
  [07:16:41.091]                     base::stop(msg)
  [07:16:41.091]                   }
  [07:16:41.091]                 })
  [07:16:41.091]             }
  [07:16:41.091]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.091]         }
  [07:16:41.091]     }
  [07:16:41.091]     if (base::is.na(NA)) {
  [07:16:41.091]     }
  [07:16:41.091]     else {
  [07:16:41.091]         if (NA) {
  [07:16:41.091]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.091]                 open = "w")
  [07:16:41.091]         }
  [07:16:41.091]         else {
  [07:16:41.091]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.091]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.091]         }
  [07:16:41.091]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.091]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.091]             base::sink(type = "output", split = FALSE)
  [07:16:41.091]             base::close(...future.stdout)
  [07:16:41.091]         }, add = TRUE)
  [07:16:41.091]     }
  [07:16:41.091]     ...future.frame <- base::sys.nframe()
  [07:16:41.091]     ...future.conditions <- base::list()
  [07:16:41.091]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.091]     ...future.result <- base::tryCatch({
  [07:16:41.091]         base::withCallingHandlers({
  [07:16:41.091]             ...future.value <- base::withVisible(base::local({
  [07:16:41.091]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.091]             }))
  [07:16:41.091]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.091]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.091]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.091]                 version = "1.8")
  [07:16:41.091]         }, condition = base::local({
  [07:16:41.091]             c <- base::c
  [07:16:41.091]             inherits <- base::inherits
  [07:16:41.091]             invokeRestart <- base::invokeRestart
  [07:16:41.091]             length <- base::length
  [07:16:41.091]             list <- base::list
  [07:16:41.091]             seq.int <- base::seq.int
  [07:16:41.091]             signalCondition <- base::signalCondition
  [07:16:41.091]             sys.calls <- base::sys.calls
  [07:16:41.091]             Sys.time <- base::Sys.time
  [07:16:41.091]             `[[` <- base::`[[`
  [07:16:41.091]             `+` <- base::`+`
  [07:16:41.091]             `<<-` <- base::`<<-`
  [07:16:41.091]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.091]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.091]                   3L)]
  [07:16:41.091]             }
  [07:16:41.091]             function(cond) {
  [07:16:41.091]                 if (inherits(cond, "error")) {
  [07:16:41.091]                   sessionInformation <- function() {
  [07:16:41.091]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.091]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.091]                       search = base::search(), system = base::Sys.info())
  [07:16:41.091]                   }
  [07:16:41.091]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.091]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.091]                     cond$call), session = sessionInformation(), 
  [07:16:41.091]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.091]                   signalCondition(cond)
  [07:16:41.091]                 }
  [07:16:41.091]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.091]                 ))) {
  [07:16:41.091]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.091]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.091]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.091]                   if (!signal) {
  [07:16:41.091]                     muffleCondition <- function (cond) 
  [07:16:41.091]                     {
  [07:16:41.091]                       inherits <- base::inherits
  [07:16:41.091]                       invokeRestart <- base::invokeRestart
  [07:16:41.091]                       muffled <- FALSE
  [07:16:41.091]                       if (inherits(cond, "message")) {
  [07:16:41.091]                         invokeRestart("muffleMessage")
  [07:16:41.091]                         muffled <- TRUE
  [07:16:41.091]                       }
  [07:16:41.091]                       else if (inherits(cond, "warning")) {
  [07:16:41.091]                         invokeRestart("muffleWarning")
  [07:16:41.091]                         muffled <- TRUE
  [07:16:41.091]                       }
  [07:16:41.091]                       else if (inherits(cond, "condition")) {
  [07:16:41.091]                         computeRestarts <- base::computeRestarts
  [07:16:41.091]                         grepl <- base::grepl
  [07:16:41.091]                         is.null <- base::is.null
  [07:16:41.091]                         restarts <- computeRestarts(cond)
  [07:16:41.091]                         for (restart in restarts) {
  [07:16:41.091]                           name <- restart$name
  [07:16:41.091]                           if (is.null(name)) 
  [07:16:41.091]                             next
  [07:16:41.091]                           if (!grepl("^muffle", name)) 
  [07:16:41.091]                             next
  [07:16:41.091]                           invokeRestart(restart)
  [07:16:41.091]                           muffled <- TRUE
  [07:16:41.091]                           break
  [07:16:41.091]                         }
  [07:16:41.091]                       }
  [07:16:41.091]                       invisible(muffled)
  [07:16:41.091]                     }
  [07:16:41.091]                     muffleCondition(cond)
  [07:16:41.091]                   }
  [07:16:41.091]                 }
  [07:16:41.091]             }
  [07:16:41.091]         }))
  [07:16:41.091]     }, error = function(ex) {
  [07:16:41.091]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.091]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.091]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.091]     }, finally = {
  [07:16:41.091]         {
  [07:16:41.091]             NULL
  [07:16:41.091]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.091]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.091]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.091]                 label = NULL, ...) 
  [07:16:41.091]             {
  [07:16:41.091]                 if (substitute) 
  [07:16:41.091]                   expr <- substitute(expr)
  [07:16:41.091]                 local <- as.logical(local)
  [07:16:41.091]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.091]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.091]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.091]                   label = label, ...)
  [07:16:41.091]                 if (!future$lazy) 
  [07:16:41.091]                   future <- run(future)
  [07:16:41.091]                 invisible(future)
  [07:16:41.091]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.091]         }
  [07:16:41.091]         base::options(...future.oldOptions)
  [07:16:41.091]     })
  [07:16:41.091]     Sys.time
  [07:16:41.091]     if (base::is.na(NA)) {
  [07:16:41.091]     }
  [07:16:41.091]     else {
  [07:16:41.091]         base::sink(type = "output", split = FALSE)
  [07:16:41.091]         if (NA) {
  [07:16:41.091]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.091]         }
  [07:16:41.091]         else {
  [07:16:41.091]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.091]         }
  [07:16:41.091]         base::close(...future.stdout)
  [07:16:41.091]         ...future.stdout <- NULL
  [07:16:41.091]     }
  [07:16:41.091]     ...future.result$conditions <- ...future.conditions
  [07:16:41.091]     ...future.result
  [07:16:41.091] }
  [07:16:41.096] plan(): Setting new future strategy stack:
  [07:16:41.097] List of future strategies:
  [07:16:41.097] 1. sequential:
  [07:16:41.097]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.097]    - tweaked: FALSE
  [07:16:41.097]    - call: NULL
  [07:16:41.099] plan(): nbrOfWorkers() = 1
  [07:16:41.102] Packages needed by the future expression (n = 0): <none>
  [07:16:41.104] Packages needed by future strategies (n = 0): <none>
  [07:16:41.109] {
  [07:16:41.109]     {
  [07:16:41.109]         ...future.startTime <- base::Sys.time()
  [07:16:41.109]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.109]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.109]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.109]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.109]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.109]         {
  [07:16:41.109]             {
  [07:16:41.109]                 base::local({
  [07:16:41.109]                   has_future <- base::requireNamespace("future", 
  [07:16:41.109]                     quietly = TRUE)
  [07:16:41.109]                   version <- if (has_future) 
  [07:16:41.109]                     utils::packageVersion("future")
  [07:16:41.109]                   else NULL
  [07:16:41.109]                   if (!has_future || version < "1.8.0") {
  [07:16:41.109]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.109]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.109]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.109]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.109]                         "release", "version")], collapse = " "), 
  [07:16:41.109]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.109]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.109]                       info)
  [07:16:41.109]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.109]                     if (!has_future) {
  [07:16:41.109]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.109]                         info)
  [07:16:41.109]                     }
  [07:16:41.109]                     else {
  [07:16:41.109]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.109]                         info, version)
  [07:16:41.109]                     }
  [07:16:41.109]                     base::stop(msg)
  [07:16:41.109]                   }
  [07:16:41.109]                 })
  [07:16:41.109]             }
  [07:16:41.109]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.109]         }
  [07:16:41.109]     }
  [07:16:41.109]     if (base::is.na(NA)) {
  [07:16:41.109]     }
  [07:16:41.109]     else {
  [07:16:41.109]         if (NA) {
  [07:16:41.109]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.109]                 open = "w")
  [07:16:41.109]         }
  [07:16:41.109]         else {
  [07:16:41.109]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.109]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.109]         }
  [07:16:41.109]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.109]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.109]             base::sink(type = "output", split = FALSE)
  [07:16:41.109]             base::close(...future.stdout)
  [07:16:41.109]         }, add = TRUE)
  [07:16:41.109]     }
  [07:16:41.109]     ...future.frame <- base::sys.nframe()
  [07:16:41.109]     ...future.conditions <- base::list()
  [07:16:41.109]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.109]     ...future.result <- base::tryCatch({
  [07:16:41.109]         base::withCallingHandlers({
  [07:16:41.109]             ...future.value <- base::withVisible(base::local({
  [07:16:41.109]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.109]             }))
  [07:16:41.109]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.109]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.109]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.109]                 version = "1.8")
  [07:16:41.109]         }, condition = base::local({
  [07:16:41.109]             c <- base::c
  [07:16:41.109]             inherits <- base::inherits
  [07:16:41.109]             invokeRestart <- base::invokeRestart
  [07:16:41.109]             length <- base::length
  [07:16:41.109]             list <- base::list
  [07:16:41.109]             seq.int <- base::seq.int
  [07:16:41.109]             signalCondition <- base::signalCondition
  [07:16:41.109]             sys.calls <- base::sys.calls
  [07:16:41.109]             Sys.time <- base::Sys.time
  [07:16:41.109]             `[[` <- base::`[[`
  [07:16:41.109]             `+` <- base::`+`
  [07:16:41.109]             `<<-` <- base::`<<-`
  [07:16:41.109]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.109]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.109]                   3L)]
  [07:16:41.109]             }
  [07:16:41.109]             function(cond) {
  [07:16:41.109]                 if (inherits(cond, "error")) {
  [07:16:41.109]                   sessionInformation <- function() {
  [07:16:41.109]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.109]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.109]                       search = base::search(), system = base::Sys.info())
  [07:16:41.109]                   }
  [07:16:41.109]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.109]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.109]                     cond$call), session = sessionInformation(), 
  [07:16:41.109]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.109]                   signalCondition(cond)
  [07:16:41.109]                 }
  [07:16:41.109]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.109]                 ))) {
  [07:16:41.109]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.109]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.109]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.109]                   if (!signal) {
  [07:16:41.109]                     muffleCondition <- function (cond) 
  [07:16:41.109]                     {
  [07:16:41.109]                       inherits <- base::inherits
  [07:16:41.109]                       invokeRestart <- base::invokeRestart
  [07:16:41.109]                       muffled <- FALSE
  [07:16:41.109]                       if (inherits(cond, "message")) {
  [07:16:41.109]                         invokeRestart("muffleMessage")
  [07:16:41.109]                         muffled <- TRUE
  [07:16:41.109]                       }
  [07:16:41.109]                       else if (inherits(cond, "warning")) {
  [07:16:41.109]                         invokeRestart("muffleWarning")
  [07:16:41.109]                         muffled <- TRUE
  [07:16:41.109]                       }
  [07:16:41.109]                       else if (inherits(cond, "condition")) {
  [07:16:41.109]                         computeRestarts <- base::computeRestarts
  [07:16:41.109]                         grepl <- base::grepl
  [07:16:41.109]                         is.null <- base::is.null
  [07:16:41.109]                         restarts <- computeRestarts(cond)
  [07:16:41.109]                         for (restart in restarts) {
  [07:16:41.109]                           name <- restart$name
  [07:16:41.109]                           if (is.null(name)) 
  [07:16:41.109]                             next
  [07:16:41.109]                           if (!grepl("^muffle", name)) 
  [07:16:41.109]                             next
  [07:16:41.109]                           invokeRestart(restart)
  [07:16:41.109]                           muffled <- TRUE
  [07:16:41.109]                           break
  [07:16:41.109]                         }
  [07:16:41.109]                       }
  [07:16:41.109]                       invisible(muffled)
  [07:16:41.109]                     }
  [07:16:41.109]                     muffleCondition(cond)
  [07:16:41.109]                   }
  [07:16:41.109]                 }
  [07:16:41.109]             }
  [07:16:41.109]         }))
  [07:16:41.109]     }, error = function(ex) {
  [07:16:41.109]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.109]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.109]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.109]     }, finally = {
  [07:16:41.109]         {
  [07:16:41.109]             NULL
  [07:16:41.109]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.109]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.109]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.109]                 label = NULL, ...) 
  [07:16:41.109]             {
  [07:16:41.109]                 if (substitute) 
  [07:16:41.109]                   expr <- substitute(expr)
  [07:16:41.109]                 local <- as.logical(local)
  [07:16:41.109]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.109]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.109]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.109]                   label = label, ...)
  [07:16:41.109]                 if (!future$lazy) 
  [07:16:41.109]                   future <- run(future)
  [07:16:41.109]                 invisible(future)
  [07:16:41.109]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.109]         }
  [07:16:41.109]         base::options(...future.oldOptions)
  [07:16:41.109]     })
  [07:16:41.109]     Sys.time
  [07:16:41.109]     if (base::is.na(NA)) {
  [07:16:41.109]     }
  [07:16:41.109]     else {
  [07:16:41.109]         base::sink(type = "output", split = FALSE)
  [07:16:41.109]         if (NA) {
  [07:16:41.109]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.109]         }
  [07:16:41.109]         else {
  [07:16:41.109]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.109]         }
  [07:16:41.109]         base::close(...future.stdout)
  [07:16:41.109]         ...future.stdout <- NULL
  [07:16:41.109]     }
  [07:16:41.109]     ...future.result$conditions <- ...future.conditions
  [07:16:41.109]     ...future.result
  [07:16:41.109] }
  [07:16:41.114] plan(): Setting new future strategy stack:
  [07:16:41.115] List of future strategies:
  [07:16:41.115] 1. sequential:
  [07:16:41.115]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.115]    - tweaked: FALSE
  [07:16:41.115]    - call: NULL
  [07:16:41.120] plan(): nbrOfWorkers() = 1
  [07:16:41.123] Packages needed by the future expression (n = 0): <none>
  [07:16:41.125] Packages needed by future strategies (n = 0): <none>
  [07:16:41.129] {
  [07:16:41.129]     {
  [07:16:41.129]         ...future.startTime <- base::Sys.time()
  [07:16:41.129]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.129]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.129]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.129]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.129]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.129]         {
  [07:16:41.129]             {
  [07:16:41.129]                 base::local({
  [07:16:41.129]                   has_future <- base::requireNamespace("future", 
  [07:16:41.129]                     quietly = TRUE)
  [07:16:41.129]                   version <- if (has_future) 
  [07:16:41.129]                     utils::packageVersion("future")
  [07:16:41.129]                   else NULL
  [07:16:41.129]                   if (!has_future || version < "1.8.0") {
  [07:16:41.129]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.129]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.129]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.129]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.129]                         "release", "version")], collapse = " "), 
  [07:16:41.129]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.129]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.129]                       info)
  [07:16:41.129]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.129]                     if (!has_future) {
  [07:16:41.129]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.129]                         info)
  [07:16:41.129]                     }
  [07:16:41.129]                     else {
  [07:16:41.129]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.129]                         info, version)
  [07:16:41.129]                     }
  [07:16:41.129]                     base::stop(msg)
  [07:16:41.129]                   }
  [07:16:41.129]                 })
  [07:16:41.129]             }
  [07:16:41.129]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.129]         }
  [07:16:41.129]     }
  [07:16:41.129]     if (base::is.na(NA)) {
  [07:16:41.129]     }
  [07:16:41.129]     else {
  [07:16:41.129]         if (NA) {
  [07:16:41.129]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.129]                 open = "w")
  [07:16:41.129]         }
  [07:16:41.129]         else {
  [07:16:41.129]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.129]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.129]         }
  [07:16:41.129]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.129]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.129]             base::sink(type = "output", split = FALSE)
  [07:16:41.129]             base::close(...future.stdout)
  [07:16:41.129]         }, add = TRUE)
  [07:16:41.129]     }
  [07:16:41.129]     ...future.frame <- base::sys.nframe()
  [07:16:41.129]     ...future.conditions <- base::list()
  [07:16:41.129]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.129]     ...future.result <- base::tryCatch({
  [07:16:41.129]         base::withCallingHandlers({
  [07:16:41.129]             ...future.value <- base::withVisible(base::local({
  [07:16:41.129]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.129]             }))
  [07:16:41.129]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.129]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.129]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.129]                 version = "1.8")
  [07:16:41.129]         }, condition = base::local({
  [07:16:41.129]             c <- base::c
  [07:16:41.129]             inherits <- base::inherits
  [07:16:41.129]             invokeRestart <- base::invokeRestart
  [07:16:41.129]             length <- base::length
  [07:16:41.129]             list <- base::list
  [07:16:41.129]             seq.int <- base::seq.int
  [07:16:41.129]             signalCondition <- base::signalCondition
  [07:16:41.129]             sys.calls <- base::sys.calls
  [07:16:41.129]             Sys.time <- base::Sys.time
  [07:16:41.129]             `[[` <- base::`[[`
  [07:16:41.129]             `+` <- base::`+`
  [07:16:41.129]             `<<-` <- base::`<<-`
  [07:16:41.129]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.129]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.129]                   3L)]
  [07:16:41.129]             }
  [07:16:41.129]             function(cond) {
  [07:16:41.129]                 if (inherits(cond, "error")) {
  [07:16:41.129]                   sessionInformation <- function() {
  [07:16:41.129]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.129]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.129]                       search = base::search(), system = base::Sys.info())
  [07:16:41.129]                   }
  [07:16:41.129]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.129]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.129]                     cond$call), session = sessionInformation(), 
  [07:16:41.129]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.129]                   signalCondition(cond)
  [07:16:41.129]                 }
  [07:16:41.129]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.129]                 ))) {
  [07:16:41.129]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.129]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.129]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.129]                   if (!signal) {
  [07:16:41.129]                     muffleCondition <- function (cond) 
  [07:16:41.129]                     {
  [07:16:41.129]                       inherits <- base::inherits
  [07:16:41.129]                       invokeRestart <- base::invokeRestart
  [07:16:41.129]                       muffled <- FALSE
  [07:16:41.129]                       if (inherits(cond, "message")) {
  [07:16:41.129]                         invokeRestart("muffleMessage")
  [07:16:41.129]                         muffled <- TRUE
  [07:16:41.129]                       }
  [07:16:41.129]                       else if (inherits(cond, "warning")) {
  [07:16:41.129]                         invokeRestart("muffleWarning")
  [07:16:41.129]                         muffled <- TRUE
  [07:16:41.129]                       }
  [07:16:41.129]                       else if (inherits(cond, "condition")) {
  [07:16:41.129]                         computeRestarts <- base::computeRestarts
  [07:16:41.129]                         grepl <- base::grepl
  [07:16:41.129]                         is.null <- base::is.null
  [07:16:41.129]                         restarts <- computeRestarts(cond)
  [07:16:41.129]                         for (restart in restarts) {
  [07:16:41.129]                           name <- restart$name
  [07:16:41.129]                           if (is.null(name)) 
  [07:16:41.129]                             next
  [07:16:41.129]                           if (!grepl("^muffle", name)) 
  [07:16:41.129]                             next
  [07:16:41.129]                           invokeRestart(restart)
  [07:16:41.129]                           muffled <- TRUE
  [07:16:41.129]                           break
  [07:16:41.129]                         }
  [07:16:41.129]                       }
  [07:16:41.129]                       invisible(muffled)
  [07:16:41.129]                     }
  [07:16:41.129]                     muffleCondition(cond)
  [07:16:41.129]                   }
  [07:16:41.129]                 }
  [07:16:41.129]             }
  [07:16:41.129]         }))
  [07:16:41.129]     }, error = function(ex) {
  [07:16:41.129]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.129]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.129]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.129]     }, finally = {
  [07:16:41.129]         {
  [07:16:41.129]             NULL
  [07:16:41.129]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.129]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.129]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.129]                 label = NULL, ...) 
  [07:16:41.129]             {
  [07:16:41.129]                 if (substitute) 
  [07:16:41.129]                   expr <- substitute(expr)
  [07:16:41.129]                 local <- as.logical(local)
  [07:16:41.129]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.129]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.129]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.129]                   label = label, ...)
  [07:16:41.129]                 if (!future$lazy) 
  [07:16:41.129]                   future <- run(future)
  [07:16:41.129]                 invisible(future)
  [07:16:41.129]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.129]         }
  [07:16:41.129]         base::options(...future.oldOptions)
  [07:16:41.129]     })
  [07:16:41.129]     Sys.time
  [07:16:41.129]     if (base::is.na(NA)) {
  [07:16:41.129]     }
  [07:16:41.129]     else {
  [07:16:41.129]         base::sink(type = "output", split = FALSE)
  [07:16:41.129]         if (NA) {
  [07:16:41.129]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.129]         }
  [07:16:41.129]         else {
  [07:16:41.129]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.129]         }
  [07:16:41.129]         base::close(...future.stdout)
  [07:16:41.129]         ...future.stdout <- NULL
  [07:16:41.129]     }
  [07:16:41.129]     ...future.result$conditions <- ...future.conditions
  [07:16:41.129]     ...future.result
  [07:16:41.129] }
  [07:16:41.134] plan(): Setting new future strategy stack:
  [07:16:41.136] List of future strategies:
  [07:16:41.136] 1. sequential:
  [07:16:41.136]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.136]    - tweaked: FALSE
  [07:16:41.136]    - call: NULL
  [07:16:41.139] plan(): nbrOfWorkers() = 1
  [07:16:41.141] plan(): Setting new future strategy stack:
  [07:16:41.142] List of future strategies:
  [07:16:41.142] 1. sequential:
  [07:16:41.142]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.142]    - tweaked: FALSE
  [07:16:41.142]    - call: NULL
  [07:16:41.145] plan(): nbrOfWorkers() = 1
  [07:16:41.147] SequentialFuture started (and completed)
  [07:16:41.149] Packages needed by the future expression (n = 0): <none>
  [07:16:41.151] Packages needed by future strategies (n = 0): <none>
  [07:16:41.156] {
  [07:16:41.156]     {
  [07:16:41.156]         ...future.startTime <- base::Sys.time()
  [07:16:41.156]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.156]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.156]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.156]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.156]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.156]         {
  [07:16:41.156]             {
  [07:16:41.156]                 base::local({
  [07:16:41.156]                   has_future <- base::requireNamespace("future", 
  [07:16:41.156]                     quietly = TRUE)
  [07:16:41.156]                   version <- if (has_future) 
  [07:16:41.156]                     utils::packageVersion("future")
  [07:16:41.156]                   else NULL
  [07:16:41.156]                   if (!has_future || version < "1.8.0") {
  [07:16:41.156]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.156]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.156]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.156]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.156]                         "release", "version")], collapse = " "), 
  [07:16:41.156]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.156]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.156]                       info)
  [07:16:41.156]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.156]                     if (!has_future) {
  [07:16:41.156]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.156]                         info)
  [07:16:41.156]                     }
  [07:16:41.156]                     else {
  [07:16:41.156]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.156]                         info, version)
  [07:16:41.156]                     }
  [07:16:41.156]                     base::stop(msg)
  [07:16:41.156]                   }
  [07:16:41.156]                 })
  [07:16:41.156]             }
  [07:16:41.156]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.156]         }
  [07:16:41.156]     }
  [07:16:41.156]     if (base::is.na(NA)) {
  [07:16:41.156]     }
  [07:16:41.156]     else {
  [07:16:41.156]         if (NA) {
  [07:16:41.156]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.156]                 open = "w")
  [07:16:41.156]         }
  [07:16:41.156]         else {
  [07:16:41.156]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.156]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.156]         }
  [07:16:41.156]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.156]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.156]             base::sink(type = "output", split = FALSE)
  [07:16:41.156]             base::close(...future.stdout)
  [07:16:41.156]         }, add = TRUE)
  [07:16:41.156]     }
  [07:16:41.156]     ...future.frame <- base::sys.nframe()
  [07:16:41.156]     ...future.conditions <- base::list()
  [07:16:41.156]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.156]     ...future.result <- base::tryCatch({
  [07:16:41.156]         base::withCallingHandlers({
  [07:16:41.156]             ...future.value <- base::withVisible(base::local({
  [07:16:41.156]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.156]             }))
  [07:16:41.156]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.156]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.156]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.156]                 version = "1.8")
  [07:16:41.156]         }, condition = base::local({
  [07:16:41.156]             c <- base::c
  [07:16:41.156]             inherits <- base::inherits
  [07:16:41.156]             invokeRestart <- base::invokeRestart
  [07:16:41.156]             length <- base::length
  [07:16:41.156]             list <- base::list
  [07:16:41.156]             seq.int <- base::seq.int
  [07:16:41.156]             signalCondition <- base::signalCondition
  [07:16:41.156]             sys.calls <- base::sys.calls
  [07:16:41.156]             Sys.time <- base::Sys.time
  [07:16:41.156]             `[[` <- base::`[[`
  [07:16:41.156]             `+` <- base::`+`
  [07:16:41.156]             `<<-` <- base::`<<-`
  [07:16:41.156]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.156]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.156]                   3L)]
  [07:16:41.156]             }
  [07:16:41.156]             function(cond) {
  [07:16:41.156]                 if (inherits(cond, "error")) {
  [07:16:41.156]                   sessionInformation <- function() {
  [07:16:41.156]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.156]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.156]                       search = base::search(), system = base::Sys.info())
  [07:16:41.156]                   }
  [07:16:41.156]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.156]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.156]                     cond$call), session = sessionInformation(), 
  [07:16:41.156]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.156]                   signalCondition(cond)
  [07:16:41.156]                 }
  [07:16:41.156]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.156]                 ))) {
  [07:16:41.156]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.156]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.156]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.156]                   if (!signal) {
  [07:16:41.156]                     muffleCondition <- function (cond) 
  [07:16:41.156]                     {
  [07:16:41.156]                       inherits <- base::inherits
  [07:16:41.156]                       invokeRestart <- base::invokeRestart
  [07:16:41.156]                       muffled <- FALSE
  [07:16:41.156]                       if (inherits(cond, "message")) {
  [07:16:41.156]                         invokeRestart("muffleMessage")
  [07:16:41.156]                         muffled <- TRUE
  [07:16:41.156]                       }
  [07:16:41.156]                       else if (inherits(cond, "warning")) {
  [07:16:41.156]                         invokeRestart("muffleWarning")
  [07:16:41.156]                         muffled <- TRUE
  [07:16:41.156]                       }
  [07:16:41.156]                       else if (inherits(cond, "condition")) {
  [07:16:41.156]                         computeRestarts <- base::computeRestarts
  [07:16:41.156]                         grepl <- base::grepl
  [07:16:41.156]                         is.null <- base::is.null
  [07:16:41.156]                         restarts <- computeRestarts(cond)
  [07:16:41.156]                         for (restart in restarts) {
  [07:16:41.156]                           name <- restart$name
  [07:16:41.156]                           if (is.null(name)) 
  [07:16:41.156]                             next
  [07:16:41.156]                           if (!grepl("^muffle", name)) 
  [07:16:41.156]                             next
  [07:16:41.156]                           invokeRestart(restart)
  [07:16:41.156]                           muffled <- TRUE
  [07:16:41.156]                           break
  [07:16:41.156]                         }
  [07:16:41.156]                       }
  [07:16:41.156]                       invisible(muffled)
  [07:16:41.156]                     }
  [07:16:41.156]                     muffleCondition(cond)
  [07:16:41.156]                   }
  [07:16:41.156]                 }
  [07:16:41.156]             }
  [07:16:41.156]         }))
  [07:16:41.156]     }, error = function(ex) {
  [07:16:41.156]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.156]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.156]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.156]     }, finally = {
  [07:16:41.156]         {
  [07:16:41.156]             NULL
  [07:16:41.156]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.156]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.156]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.156]                 label = NULL, ...) 
  [07:16:41.156]             {
  [07:16:41.156]                 if (substitute) 
  [07:16:41.156]                   expr <- substitute(expr)
  [07:16:41.156]                 local <- as.logical(local)
  [07:16:41.156]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.156]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.156]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.156]                   label = label, ...)
  [07:16:41.156]                 if (!future$lazy) 
  [07:16:41.156]                   future <- run(future)
  [07:16:41.156]                 invisible(future)
  [07:16:41.156]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.156]         }
  [07:16:41.156]         base::options(...future.oldOptions)
  [07:16:41.156]     })
  [07:16:41.156]     Sys.time
  [07:16:41.156]     if (base::is.na(NA)) {
  [07:16:41.156]     }
  [07:16:41.156]     else {
  [07:16:41.156]         base::sink(type = "output", split = FALSE)
  [07:16:41.156]         if (NA) {
  [07:16:41.156]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.156]         }
  [07:16:41.156]         else {
  [07:16:41.156]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.156]         }
  [07:16:41.156]         base::close(...future.stdout)
  [07:16:41.156]         ...future.stdout <- NULL
  [07:16:41.156]     }
  [07:16:41.156]     ...future.result$conditions <- ...future.conditions
  [07:16:41.156]     ...future.result
  [07:16:41.156] }
  [07:16:41.161] plan(): Setting new future strategy stack:
  [07:16:41.163] List of future strategies:
  [07:16:41.163] 1. sequential:
  [07:16:41.163]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.163]    - tweaked: FALSE
  [07:16:41.163]    - call: NULL
  [07:16:41.165] plan(): nbrOfWorkers() = 1
  [07:16:41.167] plan(): Setting new future strategy stack:
  [07:16:41.169] List of future strategies:
  [07:16:41.169] 1. sequential:
  [07:16:41.169]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.169]    - tweaked: FALSE
  [07:16:41.169]    - call: NULL
  [07:16:41.171] plan(): nbrOfWorkers() = 1
  [07:16:41.173] SequentialFuture started (and completed)
  [07:16:41.175] plan(): Setting new future strategy stack:
  [07:16:41.177] List of future strategies:
  [07:16:41.177] 1. sequential:
  [07:16:41.177]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.177]    - tweaked: FALSE
  [07:16:41.177]    - call: NULL
  [07:16:41.179] plan(): nbrOfWorkers() = 1
  [07:16:41.181] SequentialFuture started (and completed)
  [07:16:41.184] Packages needed by the future expression (n = 0): <none>
  [07:16:41.185] Packages needed by future strategies (n = 0): <none>
  [07:16:41.190] {
  [07:16:41.190]     {
  [07:16:41.190]         ...future.startTime <- base::Sys.time()
  [07:16:41.190]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.190]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.190]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.190]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.190]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.190]         {
  [07:16:41.190]             {
  [07:16:41.190]                 base::local({
  [07:16:41.190]                   has_future <- base::requireNamespace("future", 
  [07:16:41.190]                     quietly = TRUE)
  [07:16:41.190]                   version <- if (has_future) 
  [07:16:41.190]                     utils::packageVersion("future")
  [07:16:41.190]                   else NULL
  [07:16:41.190]                   if (!has_future || version < "1.8.0") {
  [07:16:41.190]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.190]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.190]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.190]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.190]                         "release", "version")], collapse = " "), 
  [07:16:41.190]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.190]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.190]                       info)
  [07:16:41.190]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.190]                     if (!has_future) {
  [07:16:41.190]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.190]                         info)
  [07:16:41.190]                     }
  [07:16:41.190]                     else {
  [07:16:41.190]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.190]                         info, version)
  [07:16:41.190]                     }
  [07:16:41.190]                     base::stop(msg)
  [07:16:41.190]                   }
  [07:16:41.190]                 })
  [07:16:41.190]             }
  [07:16:41.190]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.190]         }
  [07:16:41.190]     }
  [07:16:41.190]     if (base::is.na(NA)) {
  [07:16:41.190]     }
  [07:16:41.190]     else {
  [07:16:41.190]         if (NA) {
  [07:16:41.190]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.190]                 open = "w")
  [07:16:41.190]         }
  [07:16:41.190]         else {
  [07:16:41.190]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.190]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.190]         }
  [07:16:41.190]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.190]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.190]             base::sink(type = "output", split = FALSE)
  [07:16:41.190]             base::close(...future.stdout)
  [07:16:41.190]         }, add = TRUE)
  [07:16:41.190]     }
  [07:16:41.190]     ...future.frame <- base::sys.nframe()
  [07:16:41.190]     ...future.conditions <- base::list()
  [07:16:41.190]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.190]     ...future.result <- base::tryCatch({
  [07:16:41.190]         base::withCallingHandlers({
  [07:16:41.190]             ...future.value <- base::withVisible(base::local({
  [07:16:41.190]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.190]             }))
  [07:16:41.190]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.190]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.190]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.190]                 version = "1.8")
  [07:16:41.190]         }, condition = base::local({
  [07:16:41.190]             c <- base::c
  [07:16:41.190]             inherits <- base::inherits
  [07:16:41.190]             invokeRestart <- base::invokeRestart
  [07:16:41.190]             length <- base::length
  [07:16:41.190]             list <- base::list
  [07:16:41.190]             seq.int <- base::seq.int
  [07:16:41.190]             signalCondition <- base::signalCondition
  [07:16:41.190]             sys.calls <- base::sys.calls
  [07:16:41.190]             Sys.time <- base::Sys.time
  [07:16:41.190]             `[[` <- base::`[[`
  [07:16:41.190]             `+` <- base::`+`
  [07:16:41.190]             `<<-` <- base::`<<-`
  [07:16:41.190]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.190]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.190]                   3L)]
  [07:16:41.190]             }
  [07:16:41.190]             function(cond) {
  [07:16:41.190]                 if (inherits(cond, "error")) {
  [07:16:41.190]                   sessionInformation <- function() {
  [07:16:41.190]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.190]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.190]                       search = base::search(), system = base::Sys.info())
  [07:16:41.190]                   }
  [07:16:41.190]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.190]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.190]                     cond$call), session = sessionInformation(), 
  [07:16:41.190]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.190]                   signalCondition(cond)
  [07:16:41.190]                 }
  [07:16:41.190]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.190]                 ))) {
  [07:16:41.190]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.190]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.190]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.190]                   if (!signal) {
  [07:16:41.190]                     muffleCondition <- function (cond) 
  [07:16:41.190]                     {
  [07:16:41.190]                       inherits <- base::inherits
  [07:16:41.190]                       invokeRestart <- base::invokeRestart
  [07:16:41.190]                       muffled <- FALSE
  [07:16:41.190]                       if (inherits(cond, "message")) {
  [07:16:41.190]                         invokeRestart("muffleMessage")
  [07:16:41.190]                         muffled <- TRUE
  [07:16:41.190]                       }
  [07:16:41.190]                       else if (inherits(cond, "warning")) {
  [07:16:41.190]                         invokeRestart("muffleWarning")
  [07:16:41.190]                         muffled <- TRUE
  [07:16:41.190]                       }
  [07:16:41.190]                       else if (inherits(cond, "condition")) {
  [07:16:41.190]                         computeRestarts <- base::computeRestarts
  [07:16:41.190]                         grepl <- base::grepl
  [07:16:41.190]                         is.null <- base::is.null
  [07:16:41.190]                         restarts <- computeRestarts(cond)
  [07:16:41.190]                         for (restart in restarts) {
  [07:16:41.190]                           name <- restart$name
  [07:16:41.190]                           if (is.null(name)) 
  [07:16:41.190]                             next
  [07:16:41.190]                           if (!grepl("^muffle", name)) 
  [07:16:41.190]                             next
  [07:16:41.190]                           invokeRestart(restart)
  [07:16:41.190]                           muffled <- TRUE
  [07:16:41.190]                           break
  [07:16:41.190]                         }
  [07:16:41.190]                       }
  [07:16:41.190]                       invisible(muffled)
  [07:16:41.190]                     }
  [07:16:41.190]                     muffleCondition(cond)
  [07:16:41.190]                   }
  [07:16:41.190]                 }
  [07:16:41.190]             }
  [07:16:41.190]         }))
  [07:16:41.190]     }, error = function(ex) {
  [07:16:41.190]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.190]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.190]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.190]     }, finally = {
  [07:16:41.190]         {
  [07:16:41.190]             NULL
  [07:16:41.190]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.190]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.190]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.190]                 label = NULL, ...) 
  [07:16:41.190]             {
  [07:16:41.190]                 if (substitute) 
  [07:16:41.190]                   expr <- substitute(expr)
  [07:16:41.190]                 local <- as.logical(local)
  [07:16:41.190]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.190]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.190]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.190]                   label = label, ...)
  [07:16:41.190]                 if (!future$lazy) 
  [07:16:41.190]                   future <- run(future)
  [07:16:41.190]                 invisible(future)
  [07:16:41.190]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.190]         }
  [07:16:41.190]         base::options(...future.oldOptions)
  [07:16:41.190]     })
  [07:16:41.190]     Sys.time
  [07:16:41.190]     if (base::is.na(NA)) {
  [07:16:41.190]     }
  [07:16:41.190]     else {
  [07:16:41.190]         base::sink(type = "output", split = FALSE)
  [07:16:41.190]         if (NA) {
  [07:16:41.190]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.190]         }
  [07:16:41.190]         else {
  [07:16:41.190]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.190]         }
  [07:16:41.190]         base::close(...future.stdout)
  [07:16:41.190]         ...future.stdout <- NULL
  [07:16:41.190]     }
  [07:16:41.190]     ...future.result$conditions <- ...future.conditions
  [07:16:41.190]     ...future.result
  [07:16:41.190] }
  [07:16:41.197] plan(): Setting new future strategy stack:
  [07:16:41.199] List of future strategies:
  [07:16:41.199] 1. sequential:
  [07:16:41.199]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.199]    - tweaked: FALSE
  [07:16:41.199]    - call: NULL
  [07:16:41.201] plan(): nbrOfWorkers() = 1
  [07:16:41.203] plan(): Setting new future strategy stack:
  [07:16:41.205] List of future strategies:
  [07:16:41.205] 1. sequential:
  [07:16:41.205]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.205]    - tweaked: FALSE
  [07:16:41.205]    - call: NULL
  [07:16:41.207] plan(): nbrOfWorkers() = 1
  [07:16:41.209] SequentialFuture started (and completed)
  [07:16:41.211] plan(): Setting new future strategy stack:
  [07:16:41.212] List of future strategies:
  [07:16:41.212] 1. sequential:
  [07:16:41.212]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.212]    - tweaked: FALSE
  [07:16:41.212]    - call: NULL
  [07:16:41.215] plan(): nbrOfWorkers() = 1
  [07:16:41.216] SequentialFuture started (and completed)
  [07:16:41.219] Packages needed by the future expression (n = 0): <none>
  [07:16:41.221] Packages needed by future strategies (n = 0): <none>
  [07:16:41.225] {
  [07:16:41.225]     {
  [07:16:41.225]         ...future.startTime <- base::Sys.time()
  [07:16:41.225]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.225]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.225]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.225]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.225]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.225]         {
  [07:16:41.225]             {
  [07:16:41.225]                 base::local({
  [07:16:41.225]                   has_future <- base::requireNamespace("future", 
  [07:16:41.225]                     quietly = TRUE)
  [07:16:41.225]                   version <- if (has_future) 
  [07:16:41.225]                     utils::packageVersion("future")
  [07:16:41.225]                   else NULL
  [07:16:41.225]                   if (!has_future || version < "1.8.0") {
  [07:16:41.225]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.225]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.225]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.225]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.225]                         "release", "version")], collapse = " "), 
  [07:16:41.225]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.225]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.225]                       info)
  [07:16:41.225]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.225]                     if (!has_future) {
  [07:16:41.225]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.225]                         info)
  [07:16:41.225]                     }
  [07:16:41.225]                     else {
  [07:16:41.225]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.225]                         info, version)
  [07:16:41.225]                     }
  [07:16:41.225]                     base::stop(msg)
  [07:16:41.225]                   }
  [07:16:41.225]                 })
  [07:16:41.225]             }
  [07:16:41.225]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.225]         }
  [07:16:41.225]     }
  [07:16:41.225]     if (base::is.na(NA)) {
  [07:16:41.225]     }
  [07:16:41.225]     else {
  [07:16:41.225]         if (NA) {
  [07:16:41.225]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.225]                 open = "w")
  [07:16:41.225]         }
  [07:16:41.225]         else {
  [07:16:41.225]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.225]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.225]         }
  [07:16:41.225]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.225]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.225]             base::sink(type = "output", split = FALSE)
  [07:16:41.225]             base::close(...future.stdout)
  [07:16:41.225]         }, add = TRUE)
  [07:16:41.225]     }
  [07:16:41.225]     ...future.frame <- base::sys.nframe()
  [07:16:41.225]     ...future.conditions <- base::list()
  [07:16:41.225]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.225]     ...future.result <- base::tryCatch({
  [07:16:41.225]         base::withCallingHandlers({
  [07:16:41.225]             ...future.value <- base::withVisible(base::local({
  [07:16:41.225]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.225]             }))
  [07:16:41.225]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.225]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.225]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.225]                 version = "1.8")
  [07:16:41.225]         }, condition = base::local({
  [07:16:41.225]             c <- base::c
  [07:16:41.225]             inherits <- base::inherits
  [07:16:41.225]             invokeRestart <- base::invokeRestart
  [07:16:41.225]             length <- base::length
  [07:16:41.225]             list <- base::list
  [07:16:41.225]             seq.int <- base::seq.int
  [07:16:41.225]             signalCondition <- base::signalCondition
  [07:16:41.225]             sys.calls <- base::sys.calls
  [07:16:41.225]             Sys.time <- base::Sys.time
  [07:16:41.225]             `[[` <- base::`[[`
  [07:16:41.225]             `+` <- base::`+`
  [07:16:41.225]             `<<-` <- base::`<<-`
  [07:16:41.225]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.225]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.225]                   3L)]
  [07:16:41.225]             }
  [07:16:41.225]             function(cond) {
  [07:16:41.225]                 if (inherits(cond, "error")) {
  [07:16:41.225]                   sessionInformation <- function() {
  [07:16:41.225]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.225]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.225]                       search = base::search(), system = base::Sys.info())
  [07:16:41.225]                   }
  [07:16:41.225]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.225]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.225]                     cond$call), session = sessionInformation(), 
  [07:16:41.225]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.225]                   signalCondition(cond)
  [07:16:41.225]                 }
  [07:16:41.225]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.225]                 ))) {
  [07:16:41.225]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.225]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.225]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.225]                   if (!signal) {
  [07:16:41.225]                     muffleCondition <- function (cond) 
  [07:16:41.225]                     {
  [07:16:41.225]                       inherits <- base::inherits
  [07:16:41.225]                       invokeRestart <- base::invokeRestart
  [07:16:41.225]                       muffled <- FALSE
  [07:16:41.225]                       if (inherits(cond, "message")) {
  [07:16:41.225]                         invokeRestart("muffleMessage")
  [07:16:41.225]                         muffled <- TRUE
  [07:16:41.225]                       }
  [07:16:41.225]                       else if (inherits(cond, "warning")) {
  [07:16:41.225]                         invokeRestart("muffleWarning")
  [07:16:41.225]                         muffled <- TRUE
  [07:16:41.225]                       }
  [07:16:41.225]                       else if (inherits(cond, "condition")) {
  [07:16:41.225]                         computeRestarts <- base::computeRestarts
  [07:16:41.225]                         grepl <- base::grepl
  [07:16:41.225]                         is.null <- base::is.null
  [07:16:41.225]                         restarts <- computeRestarts(cond)
  [07:16:41.225]                         for (restart in restarts) {
  [07:16:41.225]                           name <- restart$name
  [07:16:41.225]                           if (is.null(name)) 
  [07:16:41.225]                             next
  [07:16:41.225]                           if (!grepl("^muffle", name)) 
  [07:16:41.225]                             next
  [07:16:41.225]                           invokeRestart(restart)
  [07:16:41.225]                           muffled <- TRUE
  [07:16:41.225]                           break
  [07:16:41.225]                         }
  [07:16:41.225]                       }
  [07:16:41.225]                       invisible(muffled)
  [07:16:41.225]                     }
  [07:16:41.225]                     muffleCondition(cond)
  [07:16:41.225]                   }
  [07:16:41.225]                 }
  [07:16:41.225]             }
  [07:16:41.225]         }))
  [07:16:41.225]     }, error = function(ex) {
  [07:16:41.225]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.225]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.225]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.225]     }, finally = {
  [07:16:41.225]         {
  [07:16:41.225]             NULL
  [07:16:41.225]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.225]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.225]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.225]                 label = NULL, ...) 
  [07:16:41.225]             {
  [07:16:41.225]                 if (substitute) 
  [07:16:41.225]                   expr <- substitute(expr)
  [07:16:41.225]                 local <- as.logical(local)
  [07:16:41.225]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.225]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.225]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.225]                   label = label, ...)
  [07:16:41.225]                 if (!future$lazy) 
  [07:16:41.225]                   future <- run(future)
  [07:16:41.225]                 invisible(future)
  [07:16:41.225]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.225]         }
  [07:16:41.225]         base::options(...future.oldOptions)
  [07:16:41.225]     })
  [07:16:41.225]     Sys.time
  [07:16:41.225]     if (base::is.na(NA)) {
  [07:16:41.225]     }
  [07:16:41.225]     else {
  [07:16:41.225]         base::sink(type = "output", split = FALSE)
  [07:16:41.225]         if (NA) {
  [07:16:41.225]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.225]         }
  [07:16:41.225]         else {
  [07:16:41.225]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.225]         }
  [07:16:41.225]         base::close(...future.stdout)
  [07:16:41.225]         ...future.stdout <- NULL
  [07:16:41.225]     }
  [07:16:41.225]     ...future.result$conditions <- ...future.conditions
  [07:16:41.225]     ...future.result
  [07:16:41.225] }
  [07:16:41.230] plan(): Setting new future strategy stack:
  [07:16:41.232] List of future strategies:
  [07:16:41.232] 1. sequential:
  [07:16:41.232]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.232]    - tweaked: FALSE
  [07:16:41.232]    - call: NULL
  [07:16:41.234] plan(): nbrOfWorkers() = 1
  [07:16:41.236] plan(): Setting new future strategy stack:
  [07:16:41.237] List of future strategies:
  [07:16:41.237] 1. sequential:
  [07:16:41.237]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.237]    - tweaked: FALSE
  [07:16:41.237]    - call: NULL
  [07:16:41.240] plan(): nbrOfWorkers() = 1
  [07:16:41.241] SequentialFuture started (and completed)
  [07:16:41.243] plan(): Setting new future strategy stack:
  [07:16:41.245] List of future strategies:
  [07:16:41.245] 1. sequential:
  [07:16:41.245]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.245]    - tweaked: FALSE
  [07:16:41.245]    - call: NULL
  [07:16:41.247] plan(): nbrOfWorkers() = 1
  [07:16:41.248] SequentialFuture started (and completed)
  [07:16:41.251] Packages needed by the future expression (n = 0): <none>
  [07:16:41.253] Packages needed by future strategies (n = 0): <none>
  [07:16:41.257] {
  [07:16:41.257]     {
  [07:16:41.257]         ...future.startTime <- base::Sys.time()
  [07:16:41.257]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.257]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.257]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.257]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.257]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.257]         {
  [07:16:41.257]             {
  [07:16:41.257]                 base::local({
  [07:16:41.257]                   has_future <- base::requireNamespace("future", 
  [07:16:41.257]                     quietly = TRUE)
  [07:16:41.257]                   version <- if (has_future) 
  [07:16:41.257]                     utils::packageVersion("future")
  [07:16:41.257]                   else NULL
  [07:16:41.257]                   if (!has_future || version < "1.8.0") {
  [07:16:41.257]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.257]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.257]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.257]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.257]                         "release", "version")], collapse = " "), 
  [07:16:41.257]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.257]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.257]                       info)
  [07:16:41.257]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.257]                     if (!has_future) {
  [07:16:41.257]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.257]                         info)
  [07:16:41.257]                     }
  [07:16:41.257]                     else {
  [07:16:41.257]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.257]                         info, version)
  [07:16:41.257]                     }
  [07:16:41.257]                     base::stop(msg)
  [07:16:41.257]                   }
  [07:16:41.257]                 })
  [07:16:41.257]             }
  [07:16:41.257]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.257]         }
  [07:16:41.257]     }
  [07:16:41.257]     if (base::is.na(NA)) {
  [07:16:41.257]     }
  [07:16:41.257]     else {
  [07:16:41.257]         if (NA) {
  [07:16:41.257]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.257]                 open = "w")
  [07:16:41.257]         }
  [07:16:41.257]         else {
  [07:16:41.257]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.257]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.257]         }
  [07:16:41.257]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.257]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.257]             base::sink(type = "output", split = FALSE)
  [07:16:41.257]             base::close(...future.stdout)
  [07:16:41.257]         }, add = TRUE)
  [07:16:41.257]     }
  [07:16:41.257]     ...future.frame <- base::sys.nframe()
  [07:16:41.257]     ...future.conditions <- base::list()
  [07:16:41.257]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.257]     ...future.result <- base::tryCatch({
  [07:16:41.257]         base::withCallingHandlers({
  [07:16:41.257]             ...future.value <- base::withVisible(base::local({
  [07:16:41.257]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.257]             }))
  [07:16:41.257]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.257]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.257]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.257]                 version = "1.8")
  [07:16:41.257]         }, condition = base::local({
  [07:16:41.257]             c <- base::c
  [07:16:41.257]             inherits <- base::inherits
  [07:16:41.257]             invokeRestart <- base::invokeRestart
  [07:16:41.257]             length <- base::length
  [07:16:41.257]             list <- base::list
  [07:16:41.257]             seq.int <- base::seq.int
  [07:16:41.257]             signalCondition <- base::signalCondition
  [07:16:41.257]             sys.calls <- base::sys.calls
  [07:16:41.257]             Sys.time <- base::Sys.time
  [07:16:41.257]             `[[` <- base::`[[`
  [07:16:41.257]             `+` <- base::`+`
  [07:16:41.257]             `<<-` <- base::`<<-`
  [07:16:41.257]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.257]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.257]                   3L)]
  [07:16:41.257]             }
  [07:16:41.257]             function(cond) {
  [07:16:41.257]                 if (inherits(cond, "error")) {
  [07:16:41.257]                   sessionInformation <- function() {
  [07:16:41.257]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.257]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.257]                       search = base::search(), system = base::Sys.info())
  [07:16:41.257]                   }
  [07:16:41.257]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.257]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.257]                     cond$call), session = sessionInformation(), 
  [07:16:41.257]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.257]                   signalCondition(cond)
  [07:16:41.257]                 }
  [07:16:41.257]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.257]                 ))) {
  [07:16:41.257]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.257]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.257]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.257]                   if (!signal) {
  [07:16:41.257]                     muffleCondition <- function (cond) 
  [07:16:41.257]                     {
  [07:16:41.257]                       inherits <- base::inherits
  [07:16:41.257]                       invokeRestart <- base::invokeRestart
  [07:16:41.257]                       muffled <- FALSE
  [07:16:41.257]                       if (inherits(cond, "message")) {
  [07:16:41.257]                         invokeRestart("muffleMessage")
  [07:16:41.257]                         muffled <- TRUE
  [07:16:41.257]                       }
  [07:16:41.257]                       else if (inherits(cond, "warning")) {
  [07:16:41.257]                         invokeRestart("muffleWarning")
  [07:16:41.257]                         muffled <- TRUE
  [07:16:41.257]                       }
  [07:16:41.257]                       else if (inherits(cond, "condition")) {
  [07:16:41.257]                         computeRestarts <- base::computeRestarts
  [07:16:41.257]                         grepl <- base::grepl
  [07:16:41.257]                         is.null <- base::is.null
  [07:16:41.257]                         restarts <- computeRestarts(cond)
  [07:16:41.257]                         for (restart in restarts) {
  [07:16:41.257]                           name <- restart$name
  [07:16:41.257]                           if (is.null(name)) 
  [07:16:41.257]                             next
  [07:16:41.257]                           if (!grepl("^muffle", name)) 
  [07:16:41.257]                             next
  [07:16:41.257]                           invokeRestart(restart)
  [07:16:41.257]                           muffled <- TRUE
  [07:16:41.257]                           break
  [07:16:41.257]                         }
  [07:16:41.257]                       }
  [07:16:41.257]                       invisible(muffled)
  [07:16:41.257]                     }
  [07:16:41.257]                     muffleCondition(cond)
  [07:16:41.257]                   }
  [07:16:41.257]                 }
  [07:16:41.257]             }
  [07:16:41.257]         }))
  [07:16:41.257]     }, error = function(ex) {
  [07:16:41.257]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.257]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.257]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.257]     }, finally = {
  [07:16:41.257]         {
  [07:16:41.257]             NULL
  [07:16:41.257]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.257]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.257]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.257]                 label = NULL, ...) 
  [07:16:41.257]             {
  [07:16:41.257]                 if (substitute) 
  [07:16:41.257]                   expr <- substitute(expr)
  [07:16:41.257]                 local <- as.logical(local)
  [07:16:41.257]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.257]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.257]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.257]                   label = label, ...)
  [07:16:41.257]                 if (!future$lazy) 
  [07:16:41.257]                   future <- run(future)
  [07:16:41.257]                 invisible(future)
  [07:16:41.257]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.257]         }
  [07:16:41.257]         base::options(...future.oldOptions)
  [07:16:41.257]     })
  [07:16:41.257]     Sys.time
  [07:16:41.257]     if (base::is.na(NA)) {
  [07:16:41.257]     }
  [07:16:41.257]     else {
  [07:16:41.257]         base::sink(type = "output", split = FALSE)
  [07:16:41.257]         if (NA) {
  [07:16:41.257]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.257]         }
  [07:16:41.257]         else {
  [07:16:41.257]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.257]         }
  [07:16:41.257]         base::close(...future.stdout)
  [07:16:41.257]         ...future.stdout <- NULL
  [07:16:41.257]     }
  [07:16:41.257]     ...future.result$conditions <- ...future.conditions
  [07:16:41.257]     ...future.result
  [07:16:41.257] }
  [07:16:41.262] plan(): Setting new future strategy stack:
  [07:16:41.263] List of future strategies:
  [07:16:41.263] 1. sequential:
  [07:16:41.263]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.263]    - tweaked: FALSE
  [07:16:41.263]    - call: NULL
  [07:16:41.265] plan(): nbrOfWorkers() = 1
  [07:16:41.267] plan(): Setting new future strategy stack:
  [07:16:41.269] List of future strategies:
  [07:16:41.269] 1. sequential:
  [07:16:41.269]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.269]    - tweaked: FALSE
  [07:16:41.269]    - call: NULL
  [07:16:41.271] plan(): nbrOfWorkers() = 1
  [07:16:41.273] SequentialFuture started (and completed)
  [07:16:41.275] plan(): Setting new future strategy stack:
  [07:16:41.276] List of future strategies:
  [07:16:41.276] 1. sequential:
  [07:16:41.276]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.276]    - tweaked: FALSE
  [07:16:41.276]    - call: NULL
  [07:16:41.278] plan(): nbrOfWorkers() = 1
  [07:16:41.280] SequentialFuture started (and completed)
  [07:16:41.284] Packages needed by the future expression (n = 0): <none>
  [07:16:41.286] Packages needed by future strategies (n = 0): <none>
  [07:16:41.290] {
  [07:16:41.290]     {
  [07:16:41.290]         ...future.startTime <- base::Sys.time()
  [07:16:41.290]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.290]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.290]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.290]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.290]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.290]         {
  [07:16:41.290]             {
  [07:16:41.290]                 base::local({
  [07:16:41.290]                   has_future <- base::requireNamespace("future", 
  [07:16:41.290]                     quietly = TRUE)
  [07:16:41.290]                   version <- if (has_future) 
  [07:16:41.290]                     utils::packageVersion("future")
  [07:16:41.290]                   else NULL
  [07:16:41.290]                   if (!has_future || version < "1.8.0") {
  [07:16:41.290]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.290]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.290]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.290]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.290]                         "release", "version")], collapse = " "), 
  [07:16:41.290]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.290]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.290]                       info)
  [07:16:41.290]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.290]                     if (!has_future) {
  [07:16:41.290]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.290]                         info)
  [07:16:41.290]                     }
  [07:16:41.290]                     else {
  [07:16:41.290]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.290]                         info, version)
  [07:16:41.290]                     }
  [07:16:41.290]                     base::stop(msg)
  [07:16:41.290]                   }
  [07:16:41.290]                 })
  [07:16:41.290]             }
  [07:16:41.290]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.290]         }
  [07:16:41.290]     }
  [07:16:41.290]     if (base::is.na(NA)) {
  [07:16:41.290]     }
  [07:16:41.290]     else {
  [07:16:41.290]         if (NA) {
  [07:16:41.290]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.290]                 open = "w")
  [07:16:41.290]         }
  [07:16:41.290]         else {
  [07:16:41.290]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.290]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.290]         }
  [07:16:41.290]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.290]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.290]             base::sink(type = "output", split = FALSE)
  [07:16:41.290]             base::close(...future.stdout)
  [07:16:41.290]         }, add = TRUE)
  [07:16:41.290]     }
  [07:16:41.290]     ...future.frame <- base::sys.nframe()
  [07:16:41.290]     ...future.conditions <- base::list()
  [07:16:41.290]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.290]     ...future.result <- base::tryCatch({
  [07:16:41.290]         base::withCallingHandlers({
  [07:16:41.290]             ...future.value <- base::withVisible(base::local({
  [07:16:41.290]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.290]             }))
  [07:16:41.290]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.290]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.290]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.290]                 version = "1.8")
  [07:16:41.290]         }, condition = base::local({
  [07:16:41.290]             c <- base::c
  [07:16:41.290]             inherits <- base::inherits
  [07:16:41.290]             invokeRestart <- base::invokeRestart
  [07:16:41.290]             length <- base::length
  [07:16:41.290]             list <- base::list
  [07:16:41.290]             seq.int <- base::seq.int
  [07:16:41.290]             signalCondition <- base::signalCondition
  [07:16:41.290]             sys.calls <- base::sys.calls
  [07:16:41.290]             Sys.time <- base::Sys.time
  [07:16:41.290]             `[[` <- base::`[[`
  [07:16:41.290]             `+` <- base::`+`
  [07:16:41.290]             `<<-` <- base::`<<-`
  [07:16:41.290]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.290]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.290]                   3L)]
  [07:16:41.290]             }
  [07:16:41.290]             function(cond) {
  [07:16:41.290]                 if (inherits(cond, "error")) {
  [07:16:41.290]                   sessionInformation <- function() {
  [07:16:41.290]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.290]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.290]                       search = base::search(), system = base::Sys.info())
  [07:16:41.290]                   }
  [07:16:41.290]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.290]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.290]                     cond$call), session = sessionInformation(), 
  [07:16:41.290]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.290]                   signalCondition(cond)
  [07:16:41.290]                 }
  [07:16:41.290]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.290]                 ))) {
  [07:16:41.290]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.290]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.290]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.290]                   if (!signal) {
  [07:16:41.290]                     muffleCondition <- function (cond) 
  [07:16:41.290]                     {
  [07:16:41.290]                       inherits <- base::inherits
  [07:16:41.290]                       invokeRestart <- base::invokeRestart
  [07:16:41.290]                       muffled <- FALSE
  [07:16:41.290]                       if (inherits(cond, "message")) {
  [07:16:41.290]                         invokeRestart("muffleMessage")
  [07:16:41.290]                         muffled <- TRUE
  [07:16:41.290]                       }
  [07:16:41.290]                       else if (inherits(cond, "warning")) {
  [07:16:41.290]                         invokeRestart("muffleWarning")
  [07:16:41.290]                         muffled <- TRUE
  [07:16:41.290]                       }
  [07:16:41.290]                       else if (inherits(cond, "condition")) {
  [07:16:41.290]                         computeRestarts <- base::computeRestarts
  [07:16:41.290]                         grepl <- base::grepl
  [07:16:41.290]                         is.null <- base::is.null
  [07:16:41.290]                         restarts <- computeRestarts(cond)
  [07:16:41.290]                         for (restart in restarts) {
  [07:16:41.290]                           name <- restart$name
  [07:16:41.290]                           if (is.null(name)) 
  [07:16:41.290]                             next
  [07:16:41.290]                           if (!grepl("^muffle", name)) 
  [07:16:41.290]                             next
  [07:16:41.290]                           invokeRestart(restart)
  [07:16:41.290]                           muffled <- TRUE
  [07:16:41.290]                           break
  [07:16:41.290]                         }
  [07:16:41.290]                       }
  [07:16:41.290]                       invisible(muffled)
  [07:16:41.290]                     }
  [07:16:41.290]                     muffleCondition(cond)
  [07:16:41.290]                   }
  [07:16:41.290]                 }
  [07:16:41.290]             }
  [07:16:41.290]         }))
  [07:16:41.290]     }, error = function(ex) {
  [07:16:41.290]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.290]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.290]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.290]     }, finally = {
  [07:16:41.290]         {
  [07:16:41.290]             NULL
  [07:16:41.290]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.290]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.290]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.290]                 label = NULL, ...) 
  [07:16:41.290]             {
  [07:16:41.290]                 if (substitute) 
  [07:16:41.290]                   expr <- substitute(expr)
  [07:16:41.290]                 local <- as.logical(local)
  [07:16:41.290]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.290]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.290]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.290]                   label = label, ...)
  [07:16:41.290]                 if (!future$lazy) 
  [07:16:41.290]                   future <- run(future)
  [07:16:41.290]                 invisible(future)
  [07:16:41.290]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.290]         }
  [07:16:41.290]         base::options(...future.oldOptions)
  [07:16:41.290]     })
  [07:16:41.290]     Sys.time
  [07:16:41.290]     if (base::is.na(NA)) {
  [07:16:41.290]     }
  [07:16:41.290]     else {
  [07:16:41.290]         base::sink(type = "output", split = FALSE)
  [07:16:41.290]         if (NA) {
  [07:16:41.290]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.290]         }
  [07:16:41.290]         else {
  [07:16:41.290]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.290]         }
  [07:16:41.290]         base::close(...future.stdout)
  [07:16:41.290]         ...future.stdout <- NULL
  [07:16:41.290]     }
  [07:16:41.290]     ...future.result$conditions <- ...future.conditions
  [07:16:41.290]     ...future.result
  [07:16:41.290] }
  [07:16:41.295] plan(): Setting new future strategy stack:
  [07:16:41.296] List of future strategies:
  [07:16:41.296] 1. sequential:
  [07:16:41.296]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.296]    - tweaked: FALSE
  [07:16:41.296]    - call: NULL
  [07:16:41.298] plan(): nbrOfWorkers() = 1
  [07:16:41.300] plan(): Setting new future strategy stack:
  [07:16:41.302] List of future strategies:
  [07:16:41.302] 1. sequential:
  [07:16:41.302]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.302]    - tweaked: FALSE
  [07:16:41.302]    - call: NULL
  [07:16:41.304] plan(): nbrOfWorkers() = 1
  [07:16:41.305] SequentialFuture started (and completed)
  [07:16:41.307] plan(): Setting new future strategy stack:
  [07:16:41.309] List of future strategies:
  [07:16:41.309] 1. sequential:
  [07:16:41.309]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.309]    - tweaked: FALSE
  [07:16:41.309]    - call: NULL
  [07:16:41.310] plan(): nbrOfWorkers() = 1
  [07:16:41.312] SequentialFuture started (and completed)
  [07:16:41.314] Packages needed by the future expression (n = 0): <none>
  [07:16:41.316] Packages needed by future strategies (n = 0): <none>
  [07:16:41.320] {
  [07:16:41.320]     {
  [07:16:41.320]         ...future.startTime <- base::Sys.time()
  [07:16:41.320]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.320]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.320]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.320]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.320]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.320]         {
  [07:16:41.320]             {
  [07:16:41.320]                 base::local({
  [07:16:41.320]                   has_future <- base::requireNamespace("future", 
  [07:16:41.320]                     quietly = TRUE)
  [07:16:41.320]                   version <- if (has_future) 
  [07:16:41.320]                     utils::packageVersion("future")
  [07:16:41.320]                   else NULL
  [07:16:41.320]                   if (!has_future || version < "1.8.0") {
  [07:16:41.320]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.320]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.320]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.320]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.320]                         "release", "version")], collapse = " "), 
  [07:16:41.320]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.320]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.320]                       info)
  [07:16:41.320]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.320]                     if (!has_future) {
  [07:16:41.320]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.320]                         info)
  [07:16:41.320]                     }
  [07:16:41.320]                     else {
  [07:16:41.320]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.320]                         info, version)
  [07:16:41.320]                     }
  [07:16:41.320]                     base::stop(msg)
  [07:16:41.320]                   }
  [07:16:41.320]                 })
  [07:16:41.320]             }
  [07:16:41.320]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.320]         }
  [07:16:41.320]     }
  [07:16:41.320]     if (base::is.na(NA)) {
  [07:16:41.320]     }
  [07:16:41.320]     else {
  [07:16:41.320]         if (NA) {
  [07:16:41.320]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.320]                 open = "w")
  [07:16:41.320]         }
  [07:16:41.320]         else {
  [07:16:41.320]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.320]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.320]         }
  [07:16:41.320]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.320]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.320]             base::sink(type = "output", split = FALSE)
  [07:16:41.320]             base::close(...future.stdout)
  [07:16:41.320]         }, add = TRUE)
  [07:16:41.320]     }
  [07:16:41.320]     ...future.frame <- base::sys.nframe()
  [07:16:41.320]     ...future.conditions <- base::list()
  [07:16:41.320]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.320]     ...future.result <- base::tryCatch({
  [07:16:41.320]         base::withCallingHandlers({
  [07:16:41.320]             ...future.value <- base::withVisible(base::local({
  [07:16:41.320]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.320]             }))
  [07:16:41.320]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.320]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.320]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.320]                 version = "1.8")
  [07:16:41.320]         }, condition = base::local({
  [07:16:41.320]             c <- base::c
  [07:16:41.320]             inherits <- base::inherits
  [07:16:41.320]             invokeRestart <- base::invokeRestart
  [07:16:41.320]             length <- base::length
  [07:16:41.320]             list <- base::list
  [07:16:41.320]             seq.int <- base::seq.int
  [07:16:41.320]             signalCondition <- base::signalCondition
  [07:16:41.320]             sys.calls <- base::sys.calls
  [07:16:41.320]             Sys.time <- base::Sys.time
  [07:16:41.320]             `[[` <- base::`[[`
  [07:16:41.320]             `+` <- base::`+`
  [07:16:41.320]             `<<-` <- base::`<<-`
  [07:16:41.320]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.320]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.320]                   3L)]
  [07:16:41.320]             }
  [07:16:41.320]             function(cond) {
  [07:16:41.320]                 if (inherits(cond, "error")) {
  [07:16:41.320]                   sessionInformation <- function() {
  [07:16:41.320]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.320]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.320]                       search = base::search(), system = base::Sys.info())
  [07:16:41.320]                   }
  [07:16:41.320]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.320]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.320]                     cond$call), session = sessionInformation(), 
  [07:16:41.320]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.320]                   signalCondition(cond)
  [07:16:41.320]                 }
  [07:16:41.320]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.320]                 ))) {
  [07:16:41.320]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.320]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.320]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.320]                   if (!signal) {
  [07:16:41.320]                     muffleCondition <- function (cond) 
  [07:16:41.320]                     {
  [07:16:41.320]                       inherits <- base::inherits
  [07:16:41.320]                       invokeRestart <- base::invokeRestart
  [07:16:41.320]                       muffled <- FALSE
  [07:16:41.320]                       if (inherits(cond, "message")) {
  [07:16:41.320]                         invokeRestart("muffleMessage")
  [07:16:41.320]                         muffled <- TRUE
  [07:16:41.320]                       }
  [07:16:41.320]                       else if (inherits(cond, "warning")) {
  [07:16:41.320]                         invokeRestart("muffleWarning")
  [07:16:41.320]                         muffled <- TRUE
  [07:16:41.320]                       }
  [07:16:41.320]                       else if (inherits(cond, "condition")) {
  [07:16:41.320]                         computeRestarts <- base::computeRestarts
  [07:16:41.320]                         grepl <- base::grepl
  [07:16:41.320]                         is.null <- base::is.null
  [07:16:41.320]                         restarts <- computeRestarts(cond)
  [07:16:41.320]                         for (restart in restarts) {
  [07:16:41.320]                           name <- restart$name
  [07:16:41.320]                           if (is.null(name)) 
  [07:16:41.320]                             next
  [07:16:41.320]                           if (!grepl("^muffle", name)) 
  [07:16:41.320]                             next
  [07:16:41.320]                           invokeRestart(restart)
  [07:16:41.320]                           muffled <- TRUE
  [07:16:41.320]                           break
  [07:16:41.320]                         }
  [07:16:41.320]                       }
  [07:16:41.320]                       invisible(muffled)
  [07:16:41.320]                     }
  [07:16:41.320]                     muffleCondition(cond)
  [07:16:41.320]                   }
  [07:16:41.320]                 }
  [07:16:41.320]             }
  [07:16:41.320]         }))
  [07:16:41.320]     }, error = function(ex) {
  [07:16:41.320]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.320]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.320]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.320]     }, finally = {
  [07:16:41.320]         {
  [07:16:41.320]             NULL
  [07:16:41.320]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.320]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.320]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.320]                 label = NULL, ...) 
  [07:16:41.320]             {
  [07:16:41.320]                 if (substitute) 
  [07:16:41.320]                   expr <- substitute(expr)
  [07:16:41.320]                 local <- as.logical(local)
  [07:16:41.320]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.320]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.320]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.320]                   label = label, ...)
  [07:16:41.320]                 if (!future$lazy) 
  [07:16:41.320]                   future <- run(future)
  [07:16:41.320]                 invisible(future)
  [07:16:41.320]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.320]         }
  [07:16:41.320]         base::options(...future.oldOptions)
  [07:16:41.320]     })
  [07:16:41.320]     Sys.time
  [07:16:41.320]     if (base::is.na(NA)) {
  [07:16:41.320]     }
  [07:16:41.320]     else {
  [07:16:41.320]         base::sink(type = "output", split = FALSE)
  [07:16:41.320]         if (NA) {
  [07:16:41.320]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.320]         }
  [07:16:41.320]         else {
  [07:16:41.320]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.320]         }
  [07:16:41.320]         base::close(...future.stdout)
  [07:16:41.320]         ...future.stdout <- NULL
  [07:16:41.320]     }
  [07:16:41.320]     ...future.result$conditions <- ...future.conditions
  [07:16:41.320]     ...future.result
  [07:16:41.320] }
  [07:16:41.325] plan(): Setting new future strategy stack:
  [07:16:41.326] List of future strategies:
  [07:16:41.326] 1. sequential:
  [07:16:41.326]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.326]    - tweaked: FALSE
  [07:16:41.326]    - call: NULL
  [07:16:41.328] plan(): nbrOfWorkers() = 1
  [07:16:41.330] plan(): Setting new future strategy stack:
  [07:16:41.331] List of future strategies:
  [07:16:41.331] 1. sequential:
  [07:16:41.331]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.331]    - tweaked: FALSE
  [07:16:41.331]    - call: NULL
  [07:16:41.333] plan(): nbrOfWorkers() = 1
  [07:16:41.335] SequentialFuture started (and completed)
  [07:16:41.336] plan(): Setting new future strategy stack:
  [07:16:41.338] List of future strategies:
  [07:16:41.338] 1. sequential:
  [07:16:41.338]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.338]    - tweaked: FALSE
  [07:16:41.338]    - call: NULL
  [07:16:41.340] plan(): nbrOfWorkers() = 1
  [07:16:41.341] SequentialFuture started (and completed)
  [07:16:41.343] Packages needed by the future expression (n = 0): <none>
  [07:16:41.345] Packages needed by future strategies (n = 0): <none>
  [07:16:41.349] {
  [07:16:41.349]     {
  [07:16:41.349]         ...future.startTime <- base::Sys.time()
  [07:16:41.349]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.349]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.349]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.349]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.349]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.349]         {
  [07:16:41.349]             {
  [07:16:41.349]                 base::local({
  [07:16:41.349]                   has_future <- base::requireNamespace("future", 
  [07:16:41.349]                     quietly = TRUE)
  [07:16:41.349]                   version <- if (has_future) 
  [07:16:41.349]                     utils::packageVersion("future")
  [07:16:41.349]                   else NULL
  [07:16:41.349]                   if (!has_future || version < "1.8.0") {
  [07:16:41.349]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.349]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.349]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.349]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.349]                         "release", "version")], collapse = " "), 
  [07:16:41.349]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.349]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.349]                       info)
  [07:16:41.349]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.349]                     if (!has_future) {
  [07:16:41.349]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.349]                         info)
  [07:16:41.349]                     }
  [07:16:41.349]                     else {
  [07:16:41.349]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.349]                         info, version)
  [07:16:41.349]                     }
  [07:16:41.349]                     base::stop(msg)
  [07:16:41.349]                   }
  [07:16:41.349]                 })
  [07:16:41.349]             }
  [07:16:41.349]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.349]         }
  [07:16:41.349]     }
  [07:16:41.349]     if (base::is.na(NA)) {
  [07:16:41.349]     }
  [07:16:41.349]     else {
  [07:16:41.349]         if (NA) {
  [07:16:41.349]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.349]                 open = "w")
  [07:16:41.349]         }
  [07:16:41.349]         else {
  [07:16:41.349]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.349]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.349]         }
  [07:16:41.349]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.349]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.349]             base::sink(type = "output", split = FALSE)
  [07:16:41.349]             base::close(...future.stdout)
  [07:16:41.349]         }, add = TRUE)
  [07:16:41.349]     }
  [07:16:41.349]     ...future.frame <- base::sys.nframe()
  [07:16:41.349]     ...future.conditions <- base::list()
  [07:16:41.349]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.349]     ...future.result <- base::tryCatch({
  [07:16:41.349]         base::withCallingHandlers({
  [07:16:41.349]             ...future.value <- base::withVisible(base::local({
  [07:16:41.349]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.349]             }))
  [07:16:41.349]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.349]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.349]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.349]                 version = "1.8")
  [07:16:41.349]         }, condition = base::local({
  [07:16:41.349]             c <- base::c
  [07:16:41.349]             inherits <- base::inherits
  [07:16:41.349]             invokeRestart <- base::invokeRestart
  [07:16:41.349]             length <- base::length
  [07:16:41.349]             list <- base::list
  [07:16:41.349]             seq.int <- base::seq.int
  [07:16:41.349]             signalCondition <- base::signalCondition
  [07:16:41.349]             sys.calls <- base::sys.calls
  [07:16:41.349]             Sys.time <- base::Sys.time
  [07:16:41.349]             `[[` <- base::`[[`
  [07:16:41.349]             `+` <- base::`+`
  [07:16:41.349]             `<<-` <- base::`<<-`
  [07:16:41.349]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.349]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.349]                   3L)]
  [07:16:41.349]             }
  [07:16:41.349]             function(cond) {
  [07:16:41.349]                 if (inherits(cond, "error")) {
  [07:16:41.349]                   sessionInformation <- function() {
  [07:16:41.349]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.349]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.349]                       search = base::search(), system = base::Sys.info())
  [07:16:41.349]                   }
  [07:16:41.349]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.349]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.349]                     cond$call), session = sessionInformation(), 
  [07:16:41.349]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.349]                   signalCondition(cond)
  [07:16:41.349]                 }
  [07:16:41.349]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.349]                 ))) {
  [07:16:41.349]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.349]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.349]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.349]                   if (!signal) {
  [07:16:41.349]                     muffleCondition <- function (cond) 
  [07:16:41.349]                     {
  [07:16:41.349]                       inherits <- base::inherits
  [07:16:41.349]                       invokeRestart <- base::invokeRestart
  [07:16:41.349]                       muffled <- FALSE
  [07:16:41.349]                       if (inherits(cond, "message")) {
  [07:16:41.349]                         invokeRestart("muffleMessage")
  [07:16:41.349]                         muffled <- TRUE
  [07:16:41.349]                       }
  [07:16:41.349]                       else if (inherits(cond, "warning")) {
  [07:16:41.349]                         invokeRestart("muffleWarning")
  [07:16:41.349]                         muffled <- TRUE
  [07:16:41.349]                       }
  [07:16:41.349]                       else if (inherits(cond, "condition")) {
  [07:16:41.349]                         computeRestarts <- base::computeRestarts
  [07:16:41.349]                         grepl <- base::grepl
  [07:16:41.349]                         is.null <- base::is.null
  [07:16:41.349]                         restarts <- computeRestarts(cond)
  [07:16:41.349]                         for (restart in restarts) {
  [07:16:41.349]                           name <- restart$name
  [07:16:41.349]                           if (is.null(name)) 
  [07:16:41.349]                             next
  [07:16:41.349]                           if (!grepl("^muffle", name)) 
  [07:16:41.349]                             next
  [07:16:41.349]                           invokeRestart(restart)
  [07:16:41.349]                           muffled <- TRUE
  [07:16:41.349]                           break
  [07:16:41.349]                         }
  [07:16:41.349]                       }
  [07:16:41.349]                       invisible(muffled)
  [07:16:41.349]                     }
  [07:16:41.349]                     muffleCondition(cond)
  [07:16:41.349]                   }
  [07:16:41.349]                 }
  [07:16:41.349]             }
  [07:16:41.349]         }))
  [07:16:41.349]     }, error = function(ex) {
  [07:16:41.349]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.349]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.349]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.349]     }, finally = {
  [07:16:41.349]         {
  [07:16:41.349]             NULL
  [07:16:41.349]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.349]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.349]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.349]                 label = NULL, ...) 
  [07:16:41.349]             {
  [07:16:41.349]                 if (substitute) 
  [07:16:41.349]                   expr <- substitute(expr)
  [07:16:41.349]                 local <- as.logical(local)
  [07:16:41.349]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.349]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.349]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.349]                   label = label, ...)
  [07:16:41.349]                 if (!future$lazy) 
  [07:16:41.349]                   future <- run(future)
  [07:16:41.349]                 invisible(future)
  [07:16:41.349]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.349]         }
  [07:16:41.349]         base::options(...future.oldOptions)
  [07:16:41.349]     })
  [07:16:41.349]     Sys.time
  [07:16:41.349]     if (base::is.na(NA)) {
  [07:16:41.349]     }
  [07:16:41.349]     else {
  [07:16:41.349]         base::sink(type = "output", split = FALSE)
  [07:16:41.349]         if (NA) {
  [07:16:41.349]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.349]         }
  [07:16:41.349]         else {
  [07:16:41.349]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.349]         }
  [07:16:41.349]         base::close(...future.stdout)
  [07:16:41.349]         ...future.stdout <- NULL
  [07:16:41.349]     }
  [07:16:41.349]     ...future.result$conditions <- ...future.conditions
  [07:16:41.349]     ...future.result
  [07:16:41.349] }
  [07:16:41.356] plan(): Setting new future strategy stack:
  [07:16:41.357] List of future strategies:
  [07:16:41.357] 1. sequential:
  [07:16:41.357]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.357]    - tweaked: FALSE
  [07:16:41.357]    - call: NULL
  [07:16:41.360] plan(): nbrOfWorkers() = 1
  [07:16:41.362] plan(): Setting new future strategy stack:
  [07:16:41.363] List of future strategies:
  [07:16:41.363] 1. sequential:
  [07:16:41.363]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.363]    - tweaked: FALSE
  [07:16:41.363]    - call: NULL
  [07:16:41.365] plan(): nbrOfWorkers() = 1
  [07:16:41.366] SequentialFuture started (and completed)
  [07:16:41.368] plan(): Setting new future strategy stack:
  [07:16:41.369] List of future strategies:
  [07:16:41.369] 1. sequential:
  [07:16:41.369]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.369]    - tweaked: FALSE
  [07:16:41.369]    - call: NULL
  [07:16:41.371] plan(): nbrOfWorkers() = 1
  [07:16:41.372] SequentialFuture started (and completed)
  [07:16:41.375] Packages needed by the future expression (n = 0): <none>
  [07:16:41.376] Packages needed by future strategies (n = 0): <none>
  [07:16:41.380] {
  [07:16:41.380]     {
  [07:16:41.380]         ...future.startTime <- base::Sys.time()
  [07:16:41.380]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.380]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.380]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.380]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.380]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.380]         {
  [07:16:41.380]             {
  [07:16:41.380]                 base::local({
  [07:16:41.380]                   has_future <- base::requireNamespace("future", 
  [07:16:41.380]                     quietly = TRUE)
  [07:16:41.380]                   version <- if (has_future) 
  [07:16:41.380]                     utils::packageVersion("future")
  [07:16:41.380]                   else NULL
  [07:16:41.380]                   if (!has_future || version < "1.8.0") {
  [07:16:41.380]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.380]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.380]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.380]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.380]                         "release", "version")], collapse = " "), 
  [07:16:41.380]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.380]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.380]                       info)
  [07:16:41.380]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.380]                     if (!has_future) {
  [07:16:41.380]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.380]                         info)
  [07:16:41.380]                     }
  [07:16:41.380]                     else {
  [07:16:41.380]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.380]                         info, version)
  [07:16:41.380]                     }
  [07:16:41.380]                     base::stop(msg)
  [07:16:41.380]                   }
  [07:16:41.380]                 })
  [07:16:41.380]             }
  [07:16:41.380]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.380]         }
  [07:16:41.380]     }
  [07:16:41.380]     if (base::is.na(NA)) {
  [07:16:41.380]     }
  [07:16:41.380]     else {
  [07:16:41.380]         if (NA) {
  [07:16:41.380]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.380]                 open = "w")
  [07:16:41.380]         }
  [07:16:41.380]         else {
  [07:16:41.380]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.380]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.380]         }
  [07:16:41.380]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.380]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.380]             base::sink(type = "output", split = FALSE)
  [07:16:41.380]             base::close(...future.stdout)
  [07:16:41.380]         }, add = TRUE)
  [07:16:41.380]     }
  [07:16:41.380]     ...future.frame <- base::sys.nframe()
  [07:16:41.380]     ...future.conditions <- base::list()
  [07:16:41.380]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.380]     ...future.result <- base::tryCatch({
  [07:16:41.380]         base::withCallingHandlers({
  [07:16:41.380]             ...future.value <- base::withVisible(base::local({
  [07:16:41.380]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.380]             }))
  [07:16:41.380]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.380]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.380]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.380]                 version = "1.8")
  [07:16:41.380]         }, condition = base::local({
  [07:16:41.380]             c <- base::c
  [07:16:41.380]             inherits <- base::inherits
  [07:16:41.380]             invokeRestart <- base::invokeRestart
  [07:16:41.380]             length <- base::length
  [07:16:41.380]             list <- base::list
  [07:16:41.380]             seq.int <- base::seq.int
  [07:16:41.380]             signalCondition <- base::signalCondition
  [07:16:41.380]             sys.calls <- base::sys.calls
  [07:16:41.380]             Sys.time <- base::Sys.time
  [07:16:41.380]             `[[` <- base::`[[`
  [07:16:41.380]             `+` <- base::`+`
  [07:16:41.380]             `<<-` <- base::`<<-`
  [07:16:41.380]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.380]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.380]                   3L)]
  [07:16:41.380]             }
  [07:16:41.380]             function(cond) {
  [07:16:41.380]                 if (inherits(cond, "error")) {
  [07:16:41.380]                   sessionInformation <- function() {
  [07:16:41.380]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.380]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.380]                       search = base::search(), system = base::Sys.info())
  [07:16:41.380]                   }
  [07:16:41.380]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.380]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.380]                     cond$call), session = sessionInformation(), 
  [07:16:41.380]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.380]                   signalCondition(cond)
  [07:16:41.380]                 }
  [07:16:41.380]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.380]                 ))) {
  [07:16:41.380]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.380]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.380]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.380]                   if (!signal) {
  [07:16:41.380]                     muffleCondition <- function (cond) 
  [07:16:41.380]                     {
  [07:16:41.380]                       inherits <- base::inherits
  [07:16:41.380]                       invokeRestart <- base::invokeRestart
  [07:16:41.380]                       muffled <- FALSE
  [07:16:41.380]                       if (inherits(cond, "message")) {
  [07:16:41.380]                         invokeRestart("muffleMessage")
  [07:16:41.380]                         muffled <- TRUE
  [07:16:41.380]                       }
  [07:16:41.380]                       else if (inherits(cond, "warning")) {
  [07:16:41.380]                         invokeRestart("muffleWarning")
  [07:16:41.380]                         muffled <- TRUE
  [07:16:41.380]                       }
  [07:16:41.380]                       else if (inherits(cond, "condition")) {
  [07:16:41.380]                         computeRestarts <- base::computeRestarts
  [07:16:41.380]                         grepl <- base::grepl
  [07:16:41.380]                         is.null <- base::is.null
  [07:16:41.380]                         restarts <- computeRestarts(cond)
  [07:16:41.380]                         for (restart in restarts) {
  [07:16:41.380]                           name <- restart$name
  [07:16:41.380]                           if (is.null(name)) 
  [07:16:41.380]                             next
  [07:16:41.380]                           if (!grepl("^muffle", name)) 
  [07:16:41.380]                             next
  [07:16:41.380]                           invokeRestart(restart)
  [07:16:41.380]                           muffled <- TRUE
  [07:16:41.380]                           break
  [07:16:41.380]                         }
  [07:16:41.380]                       }
  [07:16:41.380]                       invisible(muffled)
  [07:16:41.380]                     }
  [07:16:41.380]                     muffleCondition(cond)
  [07:16:41.380]                   }
  [07:16:41.380]                 }
  [07:16:41.380]             }
  [07:16:41.380]         }))
  [07:16:41.380]     }, error = function(ex) {
  [07:16:41.380]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.380]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.380]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.380]     }, finally = {
  [07:16:41.380]         {
  [07:16:41.380]             NULL
  [07:16:41.380]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.380]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.380]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.380]                 label = NULL, ...) 
  [07:16:41.380]             {
  [07:16:41.380]                 if (substitute) 
  [07:16:41.380]                   expr <- substitute(expr)
  [07:16:41.380]                 local <- as.logical(local)
  [07:16:41.380]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.380]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.380]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.380]                   label = label, ...)
  [07:16:41.380]                 if (!future$lazy) 
  [07:16:41.380]                   future <- run(future)
  [07:16:41.380]                 invisible(future)
  [07:16:41.380]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.380]         }
  [07:16:41.380]         base::options(...future.oldOptions)
  [07:16:41.380]     })
  [07:16:41.380]     Sys.time
  [07:16:41.380]     if (base::is.na(NA)) {
  [07:16:41.380]     }
  [07:16:41.380]     else {
  [07:16:41.380]         base::sink(type = "output", split = FALSE)
  [07:16:41.380]         if (NA) {
  [07:16:41.380]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.380]         }
  [07:16:41.380]         else {
  [07:16:41.380]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.380]         }
  [07:16:41.380]         base::close(...future.stdout)
  [07:16:41.380]         ...future.stdout <- NULL
  [07:16:41.380]     }
  [07:16:41.380]     ...future.result$conditions <- ...future.conditions
  [07:16:41.380]     ...future.result
  [07:16:41.380] }
  [07:16:41.385] plan(): Setting new future strategy stack:
  [07:16:41.386] List of future strategies:
  [07:16:41.386] 1. sequential:
  [07:16:41.386]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.386]    - tweaked: FALSE
  [07:16:41.386]    - call: NULL
  [07:16:41.388] plan(): nbrOfWorkers() = 1
  [07:16:41.389] plan(): Setting new future strategy stack:
  [07:16:41.391] List of future strategies:
  [07:16:41.391] 1. sequential:
  [07:16:41.391]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.391]    - tweaked: FALSE
  [07:16:41.391]    - call: NULL
  [07:16:41.392] plan(): nbrOfWorkers() = 1
  [07:16:41.394] SequentialFuture started (and completed)
  [07:16:41.395] plan(): Setting new future strategy stack:
  [07:16:41.396] List of future strategies:
  [07:16:41.396] 1. sequential:
  [07:16:41.396]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.396]    - tweaked: FALSE
  [07:16:41.396]    - call: NULL
  [07:16:41.398] plan(): nbrOfWorkers() = 1
  [07:16:41.399] SequentialFuture started (and completed)
  [07:16:41.402] Packages needed by the future expression (n = 0): <none>
  [07:16:41.403] Packages needed by future strategies (n = 0): <none>
  [07:16:41.407] {
  [07:16:41.407]     {
  [07:16:41.407]         ...future.startTime <- base::Sys.time()
  [07:16:41.407]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.407]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.407]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.407]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.407]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.407]         {
  [07:16:41.407]             {
  [07:16:41.407]                 base::local({
  [07:16:41.407]                   has_future <- base::requireNamespace("future", 
  [07:16:41.407]                     quietly = TRUE)
  [07:16:41.407]                   version <- if (has_future) 
  [07:16:41.407]                     utils::packageVersion("future")
  [07:16:41.407]                   else NULL
  [07:16:41.407]                   if (!has_future || version < "1.8.0") {
  [07:16:41.407]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.407]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.407]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.407]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.407]                         "release", "version")], collapse = " "), 
  [07:16:41.407]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.407]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.407]                       info)
  [07:16:41.407]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.407]                     if (!has_future) {
  [07:16:41.407]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.407]                         info)
  [07:16:41.407]                     }
  [07:16:41.407]                     else {
  [07:16:41.407]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.407]                         info, version)
  [07:16:41.407]                     }
  [07:16:41.407]                     base::stop(msg)
  [07:16:41.407]                   }
  [07:16:41.407]                 })
  [07:16:41.407]             }
  [07:16:41.407]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.407]         }
  [07:16:41.407]     }
  [07:16:41.407]     if (base::is.na(NA)) {
  [07:16:41.407]     }
  [07:16:41.407]     else {
  [07:16:41.407]         if (NA) {
  [07:16:41.407]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.407]                 open = "w")
  [07:16:41.407]         }
  [07:16:41.407]         else {
  [07:16:41.407]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.407]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.407]         }
  [07:16:41.407]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.407]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.407]             base::sink(type = "output", split = FALSE)
  [07:16:41.407]             base::close(...future.stdout)
  [07:16:41.407]         }, add = TRUE)
  [07:16:41.407]     }
  [07:16:41.407]     ...future.frame <- base::sys.nframe()
  [07:16:41.407]     ...future.conditions <- base::list()
  [07:16:41.407]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.407]     ...future.result <- base::tryCatch({
  [07:16:41.407]         base::withCallingHandlers({
  [07:16:41.407]             ...future.value <- base::withVisible(base::local({
  [07:16:41.407]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.407]             }))
  [07:16:41.407]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.407]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.407]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.407]                 version = "1.8")
  [07:16:41.407]         }, condition = base::local({
  [07:16:41.407]             c <- base::c
  [07:16:41.407]             inherits <- base::inherits
  [07:16:41.407]             invokeRestart <- base::invokeRestart
  [07:16:41.407]             length <- base::length
  [07:16:41.407]             list <- base::list
  [07:16:41.407]             seq.int <- base::seq.int
  [07:16:41.407]             signalCondition <- base::signalCondition
  [07:16:41.407]             sys.calls <- base::sys.calls
  [07:16:41.407]             Sys.time <- base::Sys.time
  [07:16:41.407]             `[[` <- base::`[[`
  [07:16:41.407]             `+` <- base::`+`
  [07:16:41.407]             `<<-` <- base::`<<-`
  [07:16:41.407]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.407]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.407]                   3L)]
  [07:16:41.407]             }
  [07:16:41.407]             function(cond) {
  [07:16:41.407]                 if (inherits(cond, "error")) {
  [07:16:41.407]                   sessionInformation <- function() {
  [07:16:41.407]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.407]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.407]                       search = base::search(), system = base::Sys.info())
  [07:16:41.407]                   }
  [07:16:41.407]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.407]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.407]                     cond$call), session = sessionInformation(), 
  [07:16:41.407]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.407]                   signalCondition(cond)
  [07:16:41.407]                 }
  [07:16:41.407]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.407]                 ))) {
  [07:16:41.407]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.407]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.407]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.407]                   if (!signal) {
  [07:16:41.407]                     muffleCondition <- function (cond) 
  [07:16:41.407]                     {
  [07:16:41.407]                       inherits <- base::inherits
  [07:16:41.407]                       invokeRestart <- base::invokeRestart
  [07:16:41.407]                       muffled <- FALSE
  [07:16:41.407]                       if (inherits(cond, "message")) {
  [07:16:41.407]                         invokeRestart("muffleMessage")
  [07:16:41.407]                         muffled <- TRUE
  [07:16:41.407]                       }
  [07:16:41.407]                       else if (inherits(cond, "warning")) {
  [07:16:41.407]                         invokeRestart("muffleWarning")
  [07:16:41.407]                         muffled <- TRUE
  [07:16:41.407]                       }
  [07:16:41.407]                       else if (inherits(cond, "condition")) {
  [07:16:41.407]                         computeRestarts <- base::computeRestarts
  [07:16:41.407]                         grepl <- base::grepl
  [07:16:41.407]                         is.null <- base::is.null
  [07:16:41.407]                         restarts <- computeRestarts(cond)
  [07:16:41.407]                         for (restart in restarts) {
  [07:16:41.407]                           name <- restart$name
  [07:16:41.407]                           if (is.null(name)) 
  [07:16:41.407]                             next
  [07:16:41.407]                           if (!grepl("^muffle", name)) 
  [07:16:41.407]                             next
  [07:16:41.407]                           invokeRestart(restart)
  [07:16:41.407]                           muffled <- TRUE
  [07:16:41.407]                           break
  [07:16:41.407]                         }
  [07:16:41.407]                       }
  [07:16:41.407]                       invisible(muffled)
  [07:16:41.407]                     }
  [07:16:41.407]                     muffleCondition(cond)
  [07:16:41.407]                   }
  [07:16:41.407]                 }
  [07:16:41.407]             }
  [07:16:41.407]         }))
  [07:16:41.407]     }, error = function(ex) {
  [07:16:41.407]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.407]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.407]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.407]     }, finally = {
  [07:16:41.407]         {
  [07:16:41.407]             NULL
  [07:16:41.407]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.407]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.407]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.407]                 label = NULL, ...) 
  [07:16:41.407]             {
  [07:16:41.407]                 if (substitute) 
  [07:16:41.407]                   expr <- substitute(expr)
  [07:16:41.407]                 local <- as.logical(local)
  [07:16:41.407]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.407]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.407]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.407]                   label = label, ...)
  [07:16:41.407]                 if (!future$lazy) 
  [07:16:41.407]                   future <- run(future)
  [07:16:41.407]                 invisible(future)
  [07:16:41.407]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.407]         }
  [07:16:41.407]         base::options(...future.oldOptions)
  [07:16:41.407]     })
  [07:16:41.407]     Sys.time
  [07:16:41.407]     if (base::is.na(NA)) {
  [07:16:41.407]     }
  [07:16:41.407]     else {
  [07:16:41.407]         base::sink(type = "output", split = FALSE)
  [07:16:41.407]         if (NA) {
  [07:16:41.407]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.407]         }
  [07:16:41.407]         else {
  [07:16:41.407]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.407]         }
  [07:16:41.407]         base::close(...future.stdout)
  [07:16:41.407]         ...future.stdout <- NULL
  [07:16:41.407]     }
  [07:16:41.407]     ...future.result$conditions <- ...future.conditions
  [07:16:41.407]     ...future.result
  [07:16:41.407] }
  [07:16:41.411] plan(): Setting new future strategy stack:
  [07:16:41.413] List of future strategies:
  [07:16:41.413] 1. sequential:
  [07:16:41.413]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.413]    - tweaked: FALSE
  [07:16:41.413]    - call: NULL
  [07:16:41.414] plan(): nbrOfWorkers() = 1
  [07:16:41.416] plan(): Setting new future strategy stack:
  [07:16:41.417] List of future strategies:
  [07:16:41.417] 1. sequential:
  [07:16:41.417]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.417]    - tweaked: FALSE
  [07:16:41.417]    - call: NULL
  [07:16:41.419] plan(): nbrOfWorkers() = 1
  [07:16:41.420] SequentialFuture started (and completed)
  [07:16:41.421] plan(): Setting new future strategy stack:
  [07:16:41.423] List of future strategies:
  [07:16:41.423] 1. sequential:
  [07:16:41.423]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.423]    - tweaked: FALSE
  [07:16:41.423]    - call: NULL
  [07:16:41.424] plan(): nbrOfWorkers() = 1
  [07:16:41.425] SequentialFuture started (and completed)
  [07:16:41.428] Packages needed by the future expression (n = 0): <none>
  [07:16:41.429] Packages needed by future strategies (n = 0): <none>
  [07:16:41.435] {
  [07:16:41.435]     {
  [07:16:41.435]         ...future.startTime <- base::Sys.time()
  [07:16:41.435]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.435]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.435]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.435]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.435]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.435]         {
  [07:16:41.435]             {
  [07:16:41.435]                 base::local({
  [07:16:41.435]                   has_future <- base::requireNamespace("future", 
  [07:16:41.435]                     quietly = TRUE)
  [07:16:41.435]                   version <- if (has_future) 
  [07:16:41.435]                     utils::packageVersion("future")
  [07:16:41.435]                   else NULL
  [07:16:41.435]                   if (!has_future || version < "1.8.0") {
  [07:16:41.435]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.435]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.435]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.435]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.435]                         "release", "version")], collapse = " "), 
  [07:16:41.435]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.435]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.435]                       info)
  [07:16:41.435]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.435]                     if (!has_future) {
  [07:16:41.435]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.435]                         info)
  [07:16:41.435]                     }
  [07:16:41.435]                     else {
  [07:16:41.435]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.435]                         info, version)
  [07:16:41.435]                     }
  [07:16:41.435]                     base::stop(msg)
  [07:16:41.435]                   }
  [07:16:41.435]                 })
  [07:16:41.435]             }
  [07:16:41.435]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.435]         }
  [07:16:41.435]     }
  [07:16:41.435]     if (base::is.na(NA)) {
  [07:16:41.435]     }
  [07:16:41.435]     else {
  [07:16:41.435]         if (NA) {
  [07:16:41.435]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.435]                 open = "w")
  [07:16:41.435]         }
  [07:16:41.435]         else {
  [07:16:41.435]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.435]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.435]         }
  [07:16:41.435]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.435]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.435]             base::sink(type = "output", split = FALSE)
  [07:16:41.435]             base::close(...future.stdout)
  [07:16:41.435]         }, add = TRUE)
  [07:16:41.435]     }
  [07:16:41.435]     ...future.frame <- base::sys.nframe()
  [07:16:41.435]     ...future.conditions <- base::list()
  [07:16:41.435]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.435]     ...future.result <- base::tryCatch({
  [07:16:41.435]         base::withCallingHandlers({
  [07:16:41.435]             ...future.value <- base::withVisible(base::local({
  [07:16:41.435]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.435]             }))
  [07:16:41.435]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.435]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.435]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.435]                 version = "1.8")
  [07:16:41.435]         }, condition = base::local({
  [07:16:41.435]             c <- base::c
  [07:16:41.435]             inherits <- base::inherits
  [07:16:41.435]             invokeRestart <- base::invokeRestart
  [07:16:41.435]             length <- base::length
  [07:16:41.435]             list <- base::list
  [07:16:41.435]             seq.int <- base::seq.int
  [07:16:41.435]             signalCondition <- base::signalCondition
  [07:16:41.435]             sys.calls <- base::sys.calls
  [07:16:41.435]             Sys.time <- base::Sys.time
  [07:16:41.435]             `[[` <- base::`[[`
  [07:16:41.435]             `+` <- base::`+`
  [07:16:41.435]             `<<-` <- base::`<<-`
  [07:16:41.435]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.435]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.435]                   3L)]
  [07:16:41.435]             }
  [07:16:41.435]             function(cond) {
  [07:16:41.435]                 if (inherits(cond, "error")) {
  [07:16:41.435]                   sessionInformation <- function() {
  [07:16:41.435]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.435]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.435]                       search = base::search(), system = base::Sys.info())
  [07:16:41.435]                   }
  [07:16:41.435]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.435]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.435]                     cond$call), session = sessionInformation(), 
  [07:16:41.435]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.435]                   signalCondition(cond)
  [07:16:41.435]                 }
  [07:16:41.435]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.435]                 ))) {
  [07:16:41.435]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.435]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.435]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.435]                   if (!signal) {
  [07:16:41.435]                     muffleCondition <- function (cond) 
  [07:16:41.435]                     {
  [07:16:41.435]                       inherits <- base::inherits
  [07:16:41.435]                       invokeRestart <- base::invokeRestart
  [07:16:41.435]                       muffled <- FALSE
  [07:16:41.435]                       if (inherits(cond, "message")) {
  [07:16:41.435]                         invokeRestart("muffleMessage")
  [07:16:41.435]                         muffled <- TRUE
  [07:16:41.435]                       }
  [07:16:41.435]                       else if (inherits(cond, "warning")) {
  [07:16:41.435]                         invokeRestart("muffleWarning")
  [07:16:41.435]                         muffled <- TRUE
  [07:16:41.435]                       }
  [07:16:41.435]                       else if (inherits(cond, "condition")) {
  [07:16:41.435]                         computeRestarts <- base::computeRestarts
  [07:16:41.435]                         grepl <- base::grepl
  [07:16:41.435]                         is.null <- base::is.null
  [07:16:41.435]                         restarts <- computeRestarts(cond)
  [07:16:41.435]                         for (restart in restarts) {
  [07:16:41.435]                           name <- restart$name
  [07:16:41.435]                           if (is.null(name)) 
  [07:16:41.435]                             next
  [07:16:41.435]                           if (!grepl("^muffle", name)) 
  [07:16:41.435]                             next
  [07:16:41.435]                           invokeRestart(restart)
  [07:16:41.435]                           muffled <- TRUE
  [07:16:41.435]                           break
  [07:16:41.435]                         }
  [07:16:41.435]                       }
  [07:16:41.435]                       invisible(muffled)
  [07:16:41.435]                     }
  [07:16:41.435]                     muffleCondition(cond)
  [07:16:41.435]                   }
  [07:16:41.435]                 }
  [07:16:41.435]             }
  [07:16:41.435]         }))
  [07:16:41.435]     }, error = function(ex) {
  [07:16:41.435]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.435]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.435]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.435]     }, finally = {
  [07:16:41.435]         {
  [07:16:41.435]             NULL
  [07:16:41.435]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.435]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.435]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.435]                 label = NULL, ...) 
  [07:16:41.435]             {
  [07:16:41.435]                 if (substitute) 
  [07:16:41.435]                   expr <- substitute(expr)
  [07:16:41.435]                 local <- as.logical(local)
  [07:16:41.435]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.435]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.435]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.435]                   label = label, ...)
  [07:16:41.435]                 if (!future$lazy) 
  [07:16:41.435]                   future <- run(future)
  [07:16:41.435]                 invisible(future)
  [07:16:41.435]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.435]         }
  [07:16:41.435]         base::options(...future.oldOptions)
  [07:16:41.435]     })
  [07:16:41.435]     Sys.time
  [07:16:41.435]     if (base::is.na(NA)) {
  [07:16:41.435]     }
  [07:16:41.435]     else {
  [07:16:41.435]         base::sink(type = "output", split = FALSE)
  [07:16:41.435]         if (NA) {
  [07:16:41.435]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.435]         }
  [07:16:41.435]         else {
  [07:16:41.435]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.435]         }
  [07:16:41.435]         base::close(...future.stdout)
  [07:16:41.435]         ...future.stdout <- NULL
  [07:16:41.435]     }
  [07:16:41.435]     ...future.result$conditions <- ...future.conditions
  [07:16:41.435]     ...future.result
  [07:16:41.435] }
  [07:16:41.440] plan(): Setting new future strategy stack:
  [07:16:41.441] List of future strategies:
  [07:16:41.441] 1. sequential:
  [07:16:41.441]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.441]    - tweaked: FALSE
  [07:16:41.441]    - call: NULL
  [07:16:41.442] plan(): nbrOfWorkers() = 1
  [07:16:41.444] plan(): Setting new future strategy stack:
  [07:16:41.445] List of future strategies:
  [07:16:41.445] 1. sequential:
  [07:16:41.445]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.445]    - tweaked: FALSE
  [07:16:41.445]    - call: NULL
  [07:16:41.447] plan(): nbrOfWorkers() = 1
  [07:16:41.448] SequentialFuture started (and completed)
  [07:16:41.449] plan(): Setting new future strategy stack:
  [07:16:41.450] List of future strategies:
  [07:16:41.450] 1. sequential:
  [07:16:41.450]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.450]    - tweaked: FALSE
  [07:16:41.450]    - call: NULL
  [07:16:41.452] plan(): nbrOfWorkers() = 1
  [07:16:41.453] SequentialFuture started (and completed)
  [07:16:41.455] Packages needed by the future expression (n = 0): <none>
  [07:16:41.456] Packages needed by future strategies (n = 0): <none>
  [07:16:41.460] {
  [07:16:41.460]     {
  [07:16:41.460]         ...future.startTime <- base::Sys.time()
  [07:16:41.460]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.460]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.460]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.460]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.460]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.460]         {
  [07:16:41.460]             {
  [07:16:41.460]                 base::local({
  [07:16:41.460]                   has_future <- base::requireNamespace("future", 
  [07:16:41.460]                     quietly = TRUE)
  [07:16:41.460]                   version <- if (has_future) 
  [07:16:41.460]                     utils::packageVersion("future")
  [07:16:41.460]                   else NULL
  [07:16:41.460]                   if (!has_future || version < "1.8.0") {
  [07:16:41.460]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.460]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.460]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.460]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.460]                         "release", "version")], collapse = " "), 
  [07:16:41.460]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.460]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.460]                       info)
  [07:16:41.460]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.460]                     if (!has_future) {
  [07:16:41.460]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.460]                         info)
  [07:16:41.460]                     }
  [07:16:41.460]                     else {
  [07:16:41.460]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.460]                         info, version)
  [07:16:41.460]                     }
  [07:16:41.460]                     base::stop(msg)
  [07:16:41.460]                   }
  [07:16:41.460]                 })
  [07:16:41.460]             }
  [07:16:41.460]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.460]         }
  [07:16:41.460]     }
  [07:16:41.460]     if (base::is.na(NA)) {
  [07:16:41.460]     }
  [07:16:41.460]     else {
  [07:16:41.460]         if (NA) {
  [07:16:41.460]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.460]                 open = "w")
  [07:16:41.460]         }
  [07:16:41.460]         else {
  [07:16:41.460]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.460]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.460]         }
  [07:16:41.460]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.460]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.460]             base::sink(type = "output", split = FALSE)
  [07:16:41.460]             base::close(...future.stdout)
  [07:16:41.460]         }, add = TRUE)
  [07:16:41.460]     }
  [07:16:41.460]     ...future.frame <- base::sys.nframe()
  [07:16:41.460]     ...future.conditions <- base::list()
  [07:16:41.460]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.460]     ...future.result <- base::tryCatch({
  [07:16:41.460]         base::withCallingHandlers({
  [07:16:41.460]             ...future.value <- base::withVisible(base::local({
  [07:16:41.460]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.460]             }))
  [07:16:41.460]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.460]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.460]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.460]                 version = "1.8")
  [07:16:41.460]         }, condition = base::local({
  [07:16:41.460]             c <- base::c
  [07:16:41.460]             inherits <- base::inherits
  [07:16:41.460]             invokeRestart <- base::invokeRestart
  [07:16:41.460]             length <- base::length
  [07:16:41.460]             list <- base::list
  [07:16:41.460]             seq.int <- base::seq.int
  [07:16:41.460]             signalCondition <- base::signalCondition
  [07:16:41.460]             sys.calls <- base::sys.calls
  [07:16:41.460]             Sys.time <- base::Sys.time
  [07:16:41.460]             `[[` <- base::`[[`
  [07:16:41.460]             `+` <- base::`+`
  [07:16:41.460]             `<<-` <- base::`<<-`
  [07:16:41.460]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.460]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.460]                   3L)]
  [07:16:41.460]             }
  [07:16:41.460]             function(cond) {
  [07:16:41.460]                 if (inherits(cond, "error")) {
  [07:16:41.460]                   sessionInformation <- function() {
  [07:16:41.460]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.460]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.460]                       search = base::search(), system = base::Sys.info())
  [07:16:41.460]                   }
  [07:16:41.460]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.460]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.460]                     cond$call), session = sessionInformation(), 
  [07:16:41.460]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.460]                   signalCondition(cond)
  [07:16:41.460]                 }
  [07:16:41.460]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.460]                 ))) {
  [07:16:41.460]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.460]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.460]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.460]                   if (!signal) {
  [07:16:41.460]                     muffleCondition <- function (cond) 
  [07:16:41.460]                     {
  [07:16:41.460]                       inherits <- base::inherits
  [07:16:41.460]                       invokeRestart <- base::invokeRestart
  [07:16:41.460]                       muffled <- FALSE
  [07:16:41.460]                       if (inherits(cond, "message")) {
  [07:16:41.460]                         invokeRestart("muffleMessage")
  [07:16:41.460]                         muffled <- TRUE
  [07:16:41.460]                       }
  [07:16:41.460]                       else if (inherits(cond, "warning")) {
  [07:16:41.460]                         invokeRestart("muffleWarning")
  [07:16:41.460]                         muffled <- TRUE
  [07:16:41.460]                       }
  [07:16:41.460]                       else if (inherits(cond, "condition")) {
  [07:16:41.460]                         computeRestarts <- base::computeRestarts
  [07:16:41.460]                         grepl <- base::grepl
  [07:16:41.460]                         is.null <- base::is.null
  [07:16:41.460]                         restarts <- computeRestarts(cond)
  [07:16:41.460]                         for (restart in restarts) {
  [07:16:41.460]                           name <- restart$name
  [07:16:41.460]                           if (is.null(name)) 
  [07:16:41.460]                             next
  [07:16:41.460]                           if (!grepl("^muffle", name)) 
  [07:16:41.460]                             next
  [07:16:41.460]                           invokeRestart(restart)
  [07:16:41.460]                           muffled <- TRUE
  [07:16:41.460]                           break
  [07:16:41.460]                         }
  [07:16:41.460]                       }
  [07:16:41.460]                       invisible(muffled)
  [07:16:41.460]                     }
  [07:16:41.460]                     muffleCondition(cond)
  [07:16:41.460]                   }
  [07:16:41.460]                 }
  [07:16:41.460]             }
  [07:16:41.460]         }))
  [07:16:41.460]     }, error = function(ex) {
  [07:16:41.460]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.460]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.460]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.460]     }, finally = {
  [07:16:41.460]         {
  [07:16:41.460]             NULL
  [07:16:41.460]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.460]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.460]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.460]                 label = NULL, ...) 
  [07:16:41.460]             {
  [07:16:41.460]                 if (substitute) 
  [07:16:41.460]                   expr <- substitute(expr)
  [07:16:41.460]                 local <- as.logical(local)
  [07:16:41.460]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.460]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.460]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.460]                   label = label, ...)
  [07:16:41.460]                 if (!future$lazy) 
  [07:16:41.460]                   future <- run(future)
  [07:16:41.460]                 invisible(future)
  [07:16:41.460]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.460]         }
  [07:16:41.460]         base::options(...future.oldOptions)
  [07:16:41.460]     })
  [07:16:41.460]     Sys.time
  [07:16:41.460]     if (base::is.na(NA)) {
  [07:16:41.460]     }
  [07:16:41.460]     else {
  [07:16:41.460]         base::sink(type = "output", split = FALSE)
  [07:16:41.460]         if (NA) {
  [07:16:41.460]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.460]         }
  [07:16:41.460]         else {
  [07:16:41.460]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.460]         }
  [07:16:41.460]         base::close(...future.stdout)
  [07:16:41.460]         ...future.stdout <- NULL
  [07:16:41.460]     }
  [07:16:41.460]     ...future.result$conditions <- ...future.conditions
  [07:16:41.460]     ...future.result
  [07:16:41.460] }
  [07:16:41.464] plan(): Setting new future strategy stack:
  [07:16:41.465] List of future strategies:
  [07:16:41.465] 1. sequential:
  [07:16:41.465]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.465]    - tweaked: FALSE
  [07:16:41.465]    - call: NULL
  [07:16:41.467] plan(): nbrOfWorkers() = 1
  [07:16:41.468] plan(): Setting new future strategy stack:
  [07:16:41.469] List of future strategies:
  [07:16:41.469] 1. sequential:
  [07:16:41.469]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.469]    - tweaked: FALSE
  [07:16:41.469]    - call: NULL
  [07:16:41.471] plan(): nbrOfWorkers() = 1
  [07:16:41.472] SequentialFuture started (and completed)
  [07:16:41.473] plan(): Setting new future strategy stack:
  [07:16:41.474] List of future strategies:
  [07:16:41.474] 1. sequential:
  [07:16:41.474]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.474]    - tweaked: FALSE
  [07:16:41.474]    - call: NULL
  [07:16:41.476] plan(): nbrOfWorkers() = 1
  [07:16:41.477] SequentialFuture started (and completed)
  [07:16:41.479] Packages needed by the future expression (n = 0): <none>
  [07:16:41.480] Packages needed by future strategies (n = 0): <none>
  [07:16:41.484] {
  [07:16:41.484]     {
  [07:16:41.484]         ...future.startTime <- base::Sys.time()
  [07:16:41.484]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.484]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.484]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.484]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.484]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.484]         {
  [07:16:41.484]             {
  [07:16:41.484]                 base::local({
  [07:16:41.484]                   has_future <- base::requireNamespace("future", 
  [07:16:41.484]                     quietly = TRUE)
  [07:16:41.484]                   version <- if (has_future) 
  [07:16:41.484]                     utils::packageVersion("future")
  [07:16:41.484]                   else NULL
  [07:16:41.484]                   if (!has_future || version < "1.8.0") {
  [07:16:41.484]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.484]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.484]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.484]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.484]                         "release", "version")], collapse = " "), 
  [07:16:41.484]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.484]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.484]                       info)
  [07:16:41.484]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.484]                     if (!has_future) {
  [07:16:41.484]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.484]                         info)
  [07:16:41.484]                     }
  [07:16:41.484]                     else {
  [07:16:41.484]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.484]                         info, version)
  [07:16:41.484]                     }
  [07:16:41.484]                     base::stop(msg)
  [07:16:41.484]                   }
  [07:16:41.484]                 })
  [07:16:41.484]             }
  [07:16:41.484]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.484]         }
  [07:16:41.484]     }
  [07:16:41.484]     if (base::is.na(NA)) {
  [07:16:41.484]     }
  [07:16:41.484]     else {
  [07:16:41.484]         if (NA) {
  [07:16:41.484]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.484]                 open = "w")
  [07:16:41.484]         }
  [07:16:41.484]         else {
  [07:16:41.484]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.484]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.484]         }
  [07:16:41.484]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.484]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.484]             base::sink(type = "output", split = FALSE)
  [07:16:41.484]             base::close(...future.stdout)
  [07:16:41.484]         }, add = TRUE)
  [07:16:41.484]     }
  [07:16:41.484]     ...future.frame <- base::sys.nframe()
  [07:16:41.484]     ...future.conditions <- base::list()
  [07:16:41.484]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.484]     ...future.result <- base::tryCatch({
  [07:16:41.484]         base::withCallingHandlers({
  [07:16:41.484]             ...future.value <- base::withVisible(base::local({
  [07:16:41.484]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.484]             }))
  [07:16:41.484]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.484]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.484]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.484]                 version = "1.8")
  [07:16:41.484]         }, condition = base::local({
  [07:16:41.484]             c <- base::c
  [07:16:41.484]             inherits <- base::inherits
  [07:16:41.484]             invokeRestart <- base::invokeRestart
  [07:16:41.484]             length <- base::length
  [07:16:41.484]             list <- base::list
  [07:16:41.484]             seq.int <- base::seq.int
  [07:16:41.484]             signalCondition <- base::signalCondition
  [07:16:41.484]             sys.calls <- base::sys.calls
  [07:16:41.484]             Sys.time <- base::Sys.time
  [07:16:41.484]             `[[` <- base::`[[`
  [07:16:41.484]             `+` <- base::`+`
  [07:16:41.484]             `<<-` <- base::`<<-`
  [07:16:41.484]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.484]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.484]                   3L)]
  [07:16:41.484]             }
  [07:16:41.484]             function(cond) {
  [07:16:41.484]                 if (inherits(cond, "error")) {
  [07:16:41.484]                   sessionInformation <- function() {
  [07:16:41.484]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.484]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.484]                       search = base::search(), system = base::Sys.info())
  [07:16:41.484]                   }
  [07:16:41.484]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.484]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.484]                     cond$call), session = sessionInformation(), 
  [07:16:41.484]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.484]                   signalCondition(cond)
  [07:16:41.484]                 }
  [07:16:41.484]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.484]                 ))) {
  [07:16:41.484]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.484]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.484]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.484]                   if (!signal) {
  [07:16:41.484]                     muffleCondition <- function (cond) 
  [07:16:41.484]                     {
  [07:16:41.484]                       inherits <- base::inherits
  [07:16:41.484]                       invokeRestart <- base::invokeRestart
  [07:16:41.484]                       muffled <- FALSE
  [07:16:41.484]                       if (inherits(cond, "message")) {
  [07:16:41.484]                         invokeRestart("muffleMessage")
  [07:16:41.484]                         muffled <- TRUE
  [07:16:41.484]                       }
  [07:16:41.484]                       else if (inherits(cond, "warning")) {
  [07:16:41.484]                         invokeRestart("muffleWarning")
  [07:16:41.484]                         muffled <- TRUE
  [07:16:41.484]                       }
  [07:16:41.484]                       else if (inherits(cond, "condition")) {
  [07:16:41.484]                         computeRestarts <- base::computeRestarts
  [07:16:41.484]                         grepl <- base::grepl
  [07:16:41.484]                         is.null <- base::is.null
  [07:16:41.484]                         restarts <- computeRestarts(cond)
  [07:16:41.484]                         for (restart in restarts) {
  [07:16:41.484]                           name <- restart$name
  [07:16:41.484]                           if (is.null(name)) 
  [07:16:41.484]                             next
  [07:16:41.484]                           if (!grepl("^muffle", name)) 
  [07:16:41.484]                             next
  [07:16:41.484]                           invokeRestart(restart)
  [07:16:41.484]                           muffled <- TRUE
  [07:16:41.484]                           break
  [07:16:41.484]                         }
  [07:16:41.484]                       }
  [07:16:41.484]                       invisible(muffled)
  [07:16:41.484]                     }
  [07:16:41.484]                     muffleCondition(cond)
  [07:16:41.484]                   }
  [07:16:41.484]                 }
  [07:16:41.484]             }
  [07:16:41.484]         }))
  [07:16:41.484]     }, error = function(ex) {
  [07:16:41.484]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.484]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.484]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.484]     }, finally = {
  [07:16:41.484]         {
  [07:16:41.484]             NULL
  [07:16:41.484]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.484]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.484]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.484]                 label = NULL, ...) 
  [07:16:41.484]             {
  [07:16:41.484]                 if (substitute) 
  [07:16:41.484]                   expr <- substitute(expr)
  [07:16:41.484]                 local <- as.logical(local)
  [07:16:41.484]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.484]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.484]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.484]                   label = label, ...)
  [07:16:41.484]                 if (!future$lazy) 
  [07:16:41.484]                   future <- run(future)
  [07:16:41.484]                 invisible(future)
  [07:16:41.484]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.484]         }
  [07:16:41.484]         base::options(...future.oldOptions)
  [07:16:41.484]     })
  [07:16:41.484]     Sys.time
  [07:16:41.484]     if (base::is.na(NA)) {
  [07:16:41.484]     }
  [07:16:41.484]     else {
  [07:16:41.484]         base::sink(type = "output", split = FALSE)
  [07:16:41.484]         if (NA) {
  [07:16:41.484]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.484]         }
  [07:16:41.484]         else {
  [07:16:41.484]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.484]         }
  [07:16:41.484]         base::close(...future.stdout)
  [07:16:41.484]         ...future.stdout <- NULL
  [07:16:41.484]     }
  [07:16:41.484]     ...future.result$conditions <- ...future.conditions
  [07:16:41.484]     ...future.result
  [07:16:41.484] }
  [07:16:41.488] plan(): Setting new future strategy stack:
  [07:16:41.489] List of future strategies:
  [07:16:41.489] 1. sequential:
  [07:16:41.489]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.489]    - tweaked: FALSE
  [07:16:41.489]    - call: NULL
  [07:16:41.490] plan(): nbrOfWorkers() = 1
  [07:16:41.492] plan(): Setting new future strategy stack:
  [07:16:41.493] List of future strategies:
  [07:16:41.493] 1. sequential:
  [07:16:41.493]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.493]    - tweaked: FALSE
  [07:16:41.493]    - call: NULL
  [07:16:41.494] plan(): nbrOfWorkers() = 1
  [07:16:41.497] SequentialFuture started (and completed)
  [07:16:41.499] plan(): Setting new future strategy stack:
  [07:16:41.499] List of future strategies:
  [07:16:41.499] 1. sequential:
  [07:16:41.499]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.499]    - tweaked: FALSE
  [07:16:41.499]    - call: NULL
  [07:16:41.501] plan(): nbrOfWorkers() = 1
  [07:16:41.502] SequentialFuture started (and completed)
  [07:16:41.504] Packages needed by the future expression (n = 0): <none>
  [07:16:41.505] Packages needed by future strategies (n = 0): <none>
  [07:16:41.509] {
  [07:16:41.509]     {
  [07:16:41.509]         ...future.startTime <- base::Sys.time()
  [07:16:41.509]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.509]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.509]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.509]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.509]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.509]         {
  [07:16:41.509]             {
  [07:16:41.509]                 base::local({
  [07:16:41.509]                   has_future <- base::requireNamespace("future", 
  [07:16:41.509]                     quietly = TRUE)
  [07:16:41.509]                   version <- if (has_future) 
  [07:16:41.509]                     utils::packageVersion("future")
  [07:16:41.509]                   else NULL
  [07:16:41.509]                   if (!has_future || version < "1.8.0") {
  [07:16:41.509]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.509]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.509]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.509]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.509]                         "release", "version")], collapse = " "), 
  [07:16:41.509]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.509]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.509]                       info)
  [07:16:41.509]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.509]                     if (!has_future) {
  [07:16:41.509]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.509]                         info)
  [07:16:41.509]                     }
  [07:16:41.509]                     else {
  [07:16:41.509]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.509]                         info, version)
  [07:16:41.509]                     }
  [07:16:41.509]                     base::stop(msg)
  [07:16:41.509]                   }
  [07:16:41.509]                 })
  [07:16:41.509]             }
  [07:16:41.509]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.509]         }
  [07:16:41.509]     }
  [07:16:41.509]     if (base::is.na(NA)) {
  [07:16:41.509]     }
  [07:16:41.509]     else {
  [07:16:41.509]         if (NA) {
  [07:16:41.509]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.509]                 open = "w")
  [07:16:41.509]         }
  [07:16:41.509]         else {
  [07:16:41.509]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.509]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.509]         }
  [07:16:41.509]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.509]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.509]             base::sink(type = "output", split = FALSE)
  [07:16:41.509]             base::close(...future.stdout)
  [07:16:41.509]         }, add = TRUE)
  [07:16:41.509]     }
  [07:16:41.509]     ...future.frame <- base::sys.nframe()
  [07:16:41.509]     ...future.conditions <- base::list()
  [07:16:41.509]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.509]     ...future.result <- base::tryCatch({
  [07:16:41.509]         base::withCallingHandlers({
  [07:16:41.509]             ...future.value <- base::withVisible(base::local({
  [07:16:41.509]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.509]             }))
  [07:16:41.509]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.509]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.509]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.509]                 version = "1.8")
  [07:16:41.509]         }, condition = base::local({
  [07:16:41.509]             c <- base::c
  [07:16:41.509]             inherits <- base::inherits
  [07:16:41.509]             invokeRestart <- base::invokeRestart
  [07:16:41.509]             length <- base::length
  [07:16:41.509]             list <- base::list
  [07:16:41.509]             seq.int <- base::seq.int
  [07:16:41.509]             signalCondition <- base::signalCondition
  [07:16:41.509]             sys.calls <- base::sys.calls
  [07:16:41.509]             Sys.time <- base::Sys.time
  [07:16:41.509]             `[[` <- base::`[[`
  [07:16:41.509]             `+` <- base::`+`
  [07:16:41.509]             `<<-` <- base::`<<-`
  [07:16:41.509]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.509]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.509]                   3L)]
  [07:16:41.509]             }
  [07:16:41.509]             function(cond) {
  [07:16:41.509]                 if (inherits(cond, "error")) {
  [07:16:41.509]                   sessionInformation <- function() {
  [07:16:41.509]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.509]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.509]                       search = base::search(), system = base::Sys.info())
  [07:16:41.509]                   }
  [07:16:41.509]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.509]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.509]                     cond$call), session = sessionInformation(), 
  [07:16:41.509]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.509]                   signalCondition(cond)
  [07:16:41.509]                 }
  [07:16:41.509]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.509]                 ))) {
  [07:16:41.509]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.509]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.509]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.509]                   if (!signal) {
  [07:16:41.509]                     muffleCondition <- function (cond) 
  [07:16:41.509]                     {
  [07:16:41.509]                       inherits <- base::inherits
  [07:16:41.509]                       invokeRestart <- base::invokeRestart
  [07:16:41.509]                       muffled <- FALSE
  [07:16:41.509]                       if (inherits(cond, "message")) {
  [07:16:41.509]                         invokeRestart("muffleMessage")
  [07:16:41.509]                         muffled <- TRUE
  [07:16:41.509]                       }
  [07:16:41.509]                       else if (inherits(cond, "warning")) {
  [07:16:41.509]                         invokeRestart("muffleWarning")
  [07:16:41.509]                         muffled <- TRUE
  [07:16:41.509]                       }
  [07:16:41.509]                       else if (inherits(cond, "condition")) {
  [07:16:41.509]                         computeRestarts <- base::computeRestarts
  [07:16:41.509]                         grepl <- base::grepl
  [07:16:41.509]                         is.null <- base::is.null
  [07:16:41.509]                         restarts <- computeRestarts(cond)
  [07:16:41.509]                         for (restart in restarts) {
  [07:16:41.509]                           name <- restart$name
  [07:16:41.509]                           if (is.null(name)) 
  [07:16:41.509]                             next
  [07:16:41.509]                           if (!grepl("^muffle", name)) 
  [07:16:41.509]                             next
  [07:16:41.509]                           invokeRestart(restart)
  [07:16:41.509]                           muffled <- TRUE
  [07:16:41.509]                           break
  [07:16:41.509]                         }
  [07:16:41.509]                       }
  [07:16:41.509]                       invisible(muffled)
  [07:16:41.509]                     }
  [07:16:41.509]                     muffleCondition(cond)
  [07:16:41.509]                   }
  [07:16:41.509]                 }
  [07:16:41.509]             }
  [07:16:41.509]         }))
  [07:16:41.509]     }, error = function(ex) {
  [07:16:41.509]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.509]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.509]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.509]     }, finally = {
  [07:16:41.509]         {
  [07:16:41.509]             NULL
  [07:16:41.509]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.509]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.509]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.509]                 label = NULL, ...) 
  [07:16:41.509]             {
  [07:16:41.509]                 if (substitute) 
  [07:16:41.509]                   expr <- substitute(expr)
  [07:16:41.509]                 local <- as.logical(local)
  [07:16:41.509]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.509]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.509]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.509]                   label = label, ...)
  [07:16:41.509]                 if (!future$lazy) 
  [07:16:41.509]                   future <- run(future)
  [07:16:41.509]                 invisible(future)
  [07:16:41.509]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.509]         }
  [07:16:41.509]         base::options(...future.oldOptions)
  [07:16:41.509]     })
  [07:16:41.509]     Sys.time
  [07:16:41.509]     if (base::is.na(NA)) {
  [07:16:41.509]     }
  [07:16:41.509]     else {
  [07:16:41.509]         base::sink(type = "output", split = FALSE)
  [07:16:41.509]         if (NA) {
  [07:16:41.509]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.509]         }
  [07:16:41.509]         else {
  [07:16:41.509]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.509]         }
  [07:16:41.509]         base::close(...future.stdout)
  [07:16:41.509]         ...future.stdout <- NULL
  [07:16:41.509]     }
  [07:16:41.509]     ...future.result$conditions <- ...future.conditions
  [07:16:41.509]     ...future.result
  [07:16:41.509] }
  [07:16:41.513] plan(): Setting new future strategy stack:
  [07:16:41.514] List of future strategies:
  [07:16:41.514] 1. sequential:
  [07:16:41.514]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.514]    - tweaked: FALSE
  [07:16:41.514]    - call: NULL
  [07:16:41.515] plan(): nbrOfWorkers() = 1
  [07:16:41.516] plan(): Setting new future strategy stack:
  [07:16:41.517] List of future strategies:
  [07:16:41.517] 1. sequential:
  [07:16:41.517]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.517]    - tweaked: FALSE
  [07:16:41.517]    - call: NULL
  [07:16:41.519] plan(): nbrOfWorkers() = 1
  [07:16:41.520] SequentialFuture started (and completed)
  [07:16:41.521] plan(): Setting new future strategy stack:
  [07:16:41.522] List of future strategies:
  [07:16:41.522] 1. sequential:
  [07:16:41.522]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.522]    - tweaked: FALSE
  [07:16:41.522]    - call: NULL
  [07:16:41.523] plan(): nbrOfWorkers() = 1
  [07:16:41.524] SequentialFuture started (and completed)
  [07:16:41.526] Packages needed by the future expression (n = 0): <none>
  [07:16:41.527] Packages needed by future strategies (n = 0): <none>
  [07:16:41.530] {
  [07:16:41.530]     {
  [07:16:41.530]         ...future.startTime <- base::Sys.time()
  [07:16:41.530]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.530]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.530]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.530]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.530]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.530]         {
  [07:16:41.530]             {
  [07:16:41.530]                 base::local({
  [07:16:41.530]                   has_future <- base::requireNamespace("future", 
  [07:16:41.530]                     quietly = TRUE)
  [07:16:41.530]                   version <- if (has_future) 
  [07:16:41.530]                     utils::packageVersion("future")
  [07:16:41.530]                   else NULL
  [07:16:41.530]                   if (!has_future || version < "1.8.0") {
  [07:16:41.530]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.530]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.530]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.530]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.530]                         "release", "version")], collapse = " "), 
  [07:16:41.530]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.530]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.530]                       info)
  [07:16:41.530]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.530]                     if (!has_future) {
  [07:16:41.530]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.530]                         info)
  [07:16:41.530]                     }
  [07:16:41.530]                     else {
  [07:16:41.530]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.530]                         info, version)
  [07:16:41.530]                     }
  [07:16:41.530]                     base::stop(msg)
  [07:16:41.530]                   }
  [07:16:41.530]                 })
  [07:16:41.530]             }
  [07:16:41.530]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.530]         }
  [07:16:41.530]     }
  [07:16:41.530]     if (base::is.na(NA)) {
  [07:16:41.530]     }
  [07:16:41.530]     else {
  [07:16:41.530]         if (NA) {
  [07:16:41.530]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.530]                 open = "w")
  [07:16:41.530]         }
  [07:16:41.530]         else {
  [07:16:41.530]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.530]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.530]         }
  [07:16:41.530]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.530]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.530]             base::sink(type = "output", split = FALSE)
  [07:16:41.530]             base::close(...future.stdout)
  [07:16:41.530]         }, add = TRUE)
  [07:16:41.530]     }
  [07:16:41.530]     ...future.frame <- base::sys.nframe()
  [07:16:41.530]     ...future.conditions <- base::list()
  [07:16:41.530]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.530]     ...future.result <- base::tryCatch({
  [07:16:41.530]         base::withCallingHandlers({
  [07:16:41.530]             ...future.value <- base::withVisible(base::local({
  [07:16:41.530]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.530]             }))
  [07:16:41.530]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.530]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.530]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.530]                 version = "1.8")
  [07:16:41.530]         }, condition = base::local({
  [07:16:41.530]             c <- base::c
  [07:16:41.530]             inherits <- base::inherits
  [07:16:41.530]             invokeRestart <- base::invokeRestart
  [07:16:41.530]             length <- base::length
  [07:16:41.530]             list <- base::list
  [07:16:41.530]             seq.int <- base::seq.int
  [07:16:41.530]             signalCondition <- base::signalCondition
  [07:16:41.530]             sys.calls <- base::sys.calls
  [07:16:41.530]             Sys.time <- base::Sys.time
  [07:16:41.530]             `[[` <- base::`[[`
  [07:16:41.530]             `+` <- base::`+`
  [07:16:41.530]             `<<-` <- base::`<<-`
  [07:16:41.530]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.530]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.530]                   3L)]
  [07:16:41.530]             }
  [07:16:41.530]             function(cond) {
  [07:16:41.530]                 if (inherits(cond, "error")) {
  [07:16:41.530]                   sessionInformation <- function() {
  [07:16:41.530]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.530]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.530]                       search = base::search(), system = base::Sys.info())
  [07:16:41.530]                   }
  [07:16:41.530]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.530]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.530]                     cond$call), session = sessionInformation(), 
  [07:16:41.530]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.530]                   signalCondition(cond)
  [07:16:41.530]                 }
  [07:16:41.530]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.530]                 ))) {
  [07:16:41.530]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.530]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.530]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.530]                   if (!signal) {
  [07:16:41.530]                     muffleCondition <- function (cond) 
  [07:16:41.530]                     {
  [07:16:41.530]                       inherits <- base::inherits
  [07:16:41.530]                       invokeRestart <- base::invokeRestart
  [07:16:41.530]                       muffled <- FALSE
  [07:16:41.530]                       if (inherits(cond, "message")) {
  [07:16:41.530]                         invokeRestart("muffleMessage")
  [07:16:41.530]                         muffled <- TRUE
  [07:16:41.530]                       }
  [07:16:41.530]                       else if (inherits(cond, "warning")) {
  [07:16:41.530]                         invokeRestart("muffleWarning")
  [07:16:41.530]                         muffled <- TRUE
  [07:16:41.530]                       }
  [07:16:41.530]                       else if (inherits(cond, "condition")) {
  [07:16:41.530]                         computeRestarts <- base::computeRestarts
  [07:16:41.530]                         grepl <- base::grepl
  [07:16:41.530]                         is.null <- base::is.null
  [07:16:41.530]                         restarts <- computeRestarts(cond)
  [07:16:41.530]                         for (restart in restarts) {
  [07:16:41.530]                           name <- restart$name
  [07:16:41.530]                           if (is.null(name)) 
  [07:16:41.530]                             next
  [07:16:41.530]                           if (!grepl("^muffle", name)) 
  [07:16:41.530]                             next
  [07:16:41.530]                           invokeRestart(restart)
  [07:16:41.530]                           muffled <- TRUE
  [07:16:41.530]                           break
  [07:16:41.530]                         }
  [07:16:41.530]                       }
  [07:16:41.530]                       invisible(muffled)
  [07:16:41.530]                     }
  [07:16:41.530]                     muffleCondition(cond)
  [07:16:41.530]                   }
  [07:16:41.530]                 }
  [07:16:41.530]             }
  [07:16:41.530]         }))
  [07:16:41.530]     }, error = function(ex) {
  [07:16:41.530]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.530]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.530]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.530]     }, finally = {
  [07:16:41.530]         {
  [07:16:41.530]             NULL
  [07:16:41.530]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.530]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.530]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.530]                 label = NULL, ...) 
  [07:16:41.530]             {
  [07:16:41.530]                 if (substitute) 
  [07:16:41.530]                   expr <- substitute(expr)
  [07:16:41.530]                 local <- as.logical(local)
  [07:16:41.530]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.530]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.530]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.530]                   label = label, ...)
  [07:16:41.530]                 if (!future$lazy) 
  [07:16:41.530]                   future <- run(future)
  [07:16:41.530]                 invisible(future)
  [07:16:41.530]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.530]         }
  [07:16:41.530]         base::options(...future.oldOptions)
  [07:16:41.530]     })
  [07:16:41.530]     Sys.time
  [07:16:41.530]     if (base::is.na(NA)) {
  [07:16:41.530]     }
  [07:16:41.530]     else {
  [07:16:41.530]         base::sink(type = "output", split = FALSE)
  [07:16:41.530]         if (NA) {
  [07:16:41.530]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.530]         }
  [07:16:41.530]         else {
  [07:16:41.530]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.530]         }
  [07:16:41.530]         base::close(...future.stdout)
  [07:16:41.530]         ...future.stdout <- NULL
  [07:16:41.530]     }
  [07:16:41.530]     ...future.result$conditions <- ...future.conditions
  [07:16:41.530]     ...future.result
  [07:16:41.530] }
  [07:16:41.534] plan(): Setting new future strategy stack:
  [07:16:41.535] List of future strategies:
  [07:16:41.535] 1. sequential:
  [07:16:41.535]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.535]    - tweaked: FALSE
  [07:16:41.535]    - call: NULL
  [07:16:41.537] plan(): nbrOfWorkers() = 1
  [07:16:41.538] plan(): Setting new future strategy stack:
  [07:16:41.539] List of future strategies:
  [07:16:41.539] 1. sequential:
  [07:16:41.539]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.539]    - tweaked: FALSE
  [07:16:41.539]    - call: NULL
  [07:16:41.540] plan(): nbrOfWorkers() = 1
  [07:16:41.541] SequentialFuture started (and completed)
  [07:16:41.542] plan(): Setting new future strategy stack:
  [07:16:41.543] List of future strategies:
  [07:16:41.543] 1. sequential:
  [07:16:41.543]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.543]    - tweaked: FALSE
  [07:16:41.543]    - call: NULL
  [07:16:41.544] plan(): nbrOfWorkers() = 1
  [07:16:41.545] SequentialFuture started (and completed)
  [07:16:41.547] Packages needed by the future expression (n = 0): <none>
  [07:16:41.547] Packages needed by future strategies (n = 0): <none>
  [07:16:41.551] {
  [07:16:41.551]     {
  [07:16:41.551]         ...future.startTime <- base::Sys.time()
  [07:16:41.551]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.551]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.551]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.551]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.551]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.551]         {
  [07:16:41.551]             {
  [07:16:41.551]                 base::local({
  [07:16:41.551]                   has_future <- base::requireNamespace("future", 
  [07:16:41.551]                     quietly = TRUE)
  [07:16:41.551]                   version <- if (has_future) 
  [07:16:41.551]                     utils::packageVersion("future")
  [07:16:41.551]                   else NULL
  [07:16:41.551]                   if (!has_future || version < "1.8.0") {
  [07:16:41.551]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.551]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.551]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.551]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.551]                         "release", "version")], collapse = " "), 
  [07:16:41.551]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.551]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.551]                       info)
  [07:16:41.551]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.551]                     if (!has_future) {
  [07:16:41.551]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.551]                         info)
  [07:16:41.551]                     }
  [07:16:41.551]                     else {
  [07:16:41.551]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.551]                         info, version)
  [07:16:41.551]                     }
  [07:16:41.551]                     base::stop(msg)
  [07:16:41.551]                   }
  [07:16:41.551]                 })
  [07:16:41.551]             }
  [07:16:41.551]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.551]         }
  [07:16:41.551]     }
  [07:16:41.551]     if (base::is.na(NA)) {
  [07:16:41.551]     }
  [07:16:41.551]     else {
  [07:16:41.551]         if (NA) {
  [07:16:41.551]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.551]                 open = "w")
  [07:16:41.551]         }
  [07:16:41.551]         else {
  [07:16:41.551]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.551]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.551]         }
  [07:16:41.551]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.551]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.551]             base::sink(type = "output", split = FALSE)
  [07:16:41.551]             base::close(...future.stdout)
  [07:16:41.551]         }, add = TRUE)
  [07:16:41.551]     }
  [07:16:41.551]     ...future.frame <- base::sys.nframe()
  [07:16:41.551]     ...future.conditions <- base::list()
  [07:16:41.551]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.551]     ...future.result <- base::tryCatch({
  [07:16:41.551]         base::withCallingHandlers({
  [07:16:41.551]             ...future.value <- base::withVisible(base::local({
  [07:16:41.551]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.551]             }))
  [07:16:41.551]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.551]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.551]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.551]                 version = "1.8")
  [07:16:41.551]         }, condition = base::local({
  [07:16:41.551]             c <- base::c
  [07:16:41.551]             inherits <- base::inherits
  [07:16:41.551]             invokeRestart <- base::invokeRestart
  [07:16:41.551]             length <- base::length
  [07:16:41.551]             list <- base::list
  [07:16:41.551]             seq.int <- base::seq.int
  [07:16:41.551]             signalCondition <- base::signalCondition
  [07:16:41.551]             sys.calls <- base::sys.calls
  [07:16:41.551]             Sys.time <- base::Sys.time
  [07:16:41.551]             `[[` <- base::`[[`
  [07:16:41.551]             `+` <- base::`+`
  [07:16:41.551]             `<<-` <- base::`<<-`
  [07:16:41.551]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.551]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.551]                   3L)]
  [07:16:41.551]             }
  [07:16:41.551]             function(cond) {
  [07:16:41.551]                 if (inherits(cond, "error")) {
  [07:16:41.551]                   sessionInformation <- function() {
  [07:16:41.551]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.551]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.551]                       search = base::search(), system = base::Sys.info())
  [07:16:41.551]                   }
  [07:16:41.551]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.551]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.551]                     cond$call), session = sessionInformation(), 
  [07:16:41.551]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.551]                   signalCondition(cond)
  [07:16:41.551]                 }
  [07:16:41.551]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.551]                 ))) {
  [07:16:41.551]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.551]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.551]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.551]                   if (!signal) {
  [07:16:41.551]                     muffleCondition <- function (cond) 
  [07:16:41.551]                     {
  [07:16:41.551]                       inherits <- base::inherits
  [07:16:41.551]                       invokeRestart <- base::invokeRestart
  [07:16:41.551]                       muffled <- FALSE
  [07:16:41.551]                       if (inherits(cond, "message")) {
  [07:16:41.551]                         invokeRestart("muffleMessage")
  [07:16:41.551]                         muffled <- TRUE
  [07:16:41.551]                       }
  [07:16:41.551]                       else if (inherits(cond, "warning")) {
  [07:16:41.551]                         invokeRestart("muffleWarning")
  [07:16:41.551]                         muffled <- TRUE
  [07:16:41.551]                       }
  [07:16:41.551]                       else if (inherits(cond, "condition")) {
  [07:16:41.551]                         computeRestarts <- base::computeRestarts
  [07:16:41.551]                         grepl <- base::grepl
  [07:16:41.551]                         is.null <- base::is.null
  [07:16:41.551]                         restarts <- computeRestarts(cond)
  [07:16:41.551]                         for (restart in restarts) {
  [07:16:41.551]                           name <- restart$name
  [07:16:41.551]                           if (is.null(name)) 
  [07:16:41.551]                             next
  [07:16:41.551]                           if (!grepl("^muffle", name)) 
  [07:16:41.551]                             next
  [07:16:41.551]                           invokeRestart(restart)
  [07:16:41.551]                           muffled <- TRUE
  [07:16:41.551]                           break
  [07:16:41.551]                         }
  [07:16:41.551]                       }
  [07:16:41.551]                       invisible(muffled)
  [07:16:41.551]                     }
  [07:16:41.551]                     muffleCondition(cond)
  [07:16:41.551]                   }
  [07:16:41.551]                 }
  [07:16:41.551]             }
  [07:16:41.551]         }))
  [07:16:41.551]     }, error = function(ex) {
  [07:16:41.551]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.551]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.551]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.551]     }, finally = {
  [07:16:41.551]         {
  [07:16:41.551]             NULL
  [07:16:41.551]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.551]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.551]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.551]                 label = NULL, ...) 
  [07:16:41.551]             {
  [07:16:41.551]                 if (substitute) 
  [07:16:41.551]                   expr <- substitute(expr)
  [07:16:41.551]                 local <- as.logical(local)
  [07:16:41.551]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.551]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.551]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.551]                   label = label, ...)
  [07:16:41.551]                 if (!future$lazy) 
  [07:16:41.551]                   future <- run(future)
  [07:16:41.551]                 invisible(future)
  [07:16:41.551]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.551]         }
  [07:16:41.551]         base::options(...future.oldOptions)
  [07:16:41.551]     })
  [07:16:41.551]     Sys.time
  [07:16:41.551]     if (base::is.na(NA)) {
  [07:16:41.551]     }
  [07:16:41.551]     else {
  [07:16:41.551]         base::sink(type = "output", split = FALSE)
  [07:16:41.551]         if (NA) {
  [07:16:41.551]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.551]         }
  [07:16:41.551]         else {
  [07:16:41.551]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.551]         }
  [07:16:41.551]         base::close(...future.stdout)
  [07:16:41.551]         ...future.stdout <- NULL
  [07:16:41.551]     }
  [07:16:41.551]     ...future.result$conditions <- ...future.conditions
  [07:16:41.551]     ...future.result
  [07:16:41.551] }
  [07:16:41.560] plan(): Setting new future strategy stack:
  [07:16:41.560] List of future strategies:
  [07:16:41.560] 1. sequential:
  [07:16:41.560]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.560]    - tweaked: FALSE
  [07:16:41.560]    - call: NULL
  [07:16:41.562] plan(): nbrOfWorkers() = 1
  [07:16:41.563] plan(): Setting new future strategy stack:
  [07:16:41.564] List of future strategies:
  [07:16:41.564] 1. sequential:
  [07:16:41.564]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.564]    - tweaked: FALSE
  [07:16:41.564]    - call: NULL
  [07:16:41.565] plan(): nbrOfWorkers() = 1
  [07:16:41.566] SequentialFuture started (and completed)
  [07:16:41.567] plan(): Setting new future strategy stack:
  [07:16:41.567] List of future strategies:
  [07:16:41.567] 1. sequential:
  [07:16:41.567]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.567]    - tweaked: FALSE
  [07:16:41.567]    - call: NULL
  [07:16:41.569] plan(): nbrOfWorkers() = 1
  [07:16:41.569] SequentialFuture started (and completed)
  [07:16:41.571] Packages needed by the future expression (n = 0): <none>
  [07:16:41.572] Packages needed by future strategies (n = 0): <none>
  [07:16:41.576] {
  [07:16:41.576]     {
  [07:16:41.576]         ...future.startTime <- base::Sys.time()
  [07:16:41.576]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.576]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.576]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.576]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.576]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.576]         {
  [07:16:41.576]             {
  [07:16:41.576]                 base::local({
  [07:16:41.576]                   has_future <- base::requireNamespace("future", 
  [07:16:41.576]                     quietly = TRUE)
  [07:16:41.576]                   version <- if (has_future) 
  [07:16:41.576]                     utils::packageVersion("future")
  [07:16:41.576]                   else NULL
  [07:16:41.576]                   if (!has_future || version < "1.8.0") {
  [07:16:41.576]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.576]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.576]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.576]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.576]                         "release", "version")], collapse = " "), 
  [07:16:41.576]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.576]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.576]                       info)
  [07:16:41.576]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.576]                     if (!has_future) {
  [07:16:41.576]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.576]                         info)
  [07:16:41.576]                     }
  [07:16:41.576]                     else {
  [07:16:41.576]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.576]                         info, version)
  [07:16:41.576]                     }
  [07:16:41.576]                     base::stop(msg)
  [07:16:41.576]                   }
  [07:16:41.576]                 })
  [07:16:41.576]             }
  [07:16:41.576]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.576]         }
  [07:16:41.576]     }
  [07:16:41.576]     if (base::is.na(NA)) {
  [07:16:41.576]     }
  [07:16:41.576]     else {
  [07:16:41.576]         if (NA) {
  [07:16:41.576]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.576]                 open = "w")
  [07:16:41.576]         }
  [07:16:41.576]         else {
  [07:16:41.576]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.576]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.576]         }
  [07:16:41.576]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.576]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.576]             base::sink(type = "output", split = FALSE)
  [07:16:41.576]             base::close(...future.stdout)
  [07:16:41.576]         }, add = TRUE)
  [07:16:41.576]     }
  [07:16:41.576]     ...future.frame <- base::sys.nframe()
  [07:16:41.576]     ...future.conditions <- base::list()
  [07:16:41.576]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.576]     ...future.result <- base::tryCatch({
  [07:16:41.576]         base::withCallingHandlers({
  [07:16:41.576]             ...future.value <- base::withVisible(base::local({
  [07:16:41.576]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.576]             }))
  [07:16:41.576]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.576]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.576]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.576]                 version = "1.8")
  [07:16:41.576]         }, condition = base::local({
  [07:16:41.576]             c <- base::c
  [07:16:41.576]             inherits <- base::inherits
  [07:16:41.576]             invokeRestart <- base::invokeRestart
  [07:16:41.576]             length <- base::length
  [07:16:41.576]             list <- base::list
  [07:16:41.576]             seq.int <- base::seq.int
  [07:16:41.576]             signalCondition <- base::signalCondition
  [07:16:41.576]             sys.calls <- base::sys.calls
  [07:16:41.576]             Sys.time <- base::Sys.time
  [07:16:41.576]             `[[` <- base::`[[`
  [07:16:41.576]             `+` <- base::`+`
  [07:16:41.576]             `<<-` <- base::`<<-`
  [07:16:41.576]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.576]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.576]                   3L)]
  [07:16:41.576]             }
  [07:16:41.576]             function(cond) {
  [07:16:41.576]                 if (inherits(cond, "error")) {
  [07:16:41.576]                   sessionInformation <- function() {
  [07:16:41.576]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.576]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.576]                       search = base::search(), system = base::Sys.info())
  [07:16:41.576]                   }
  [07:16:41.576]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.576]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.576]                     cond$call), session = sessionInformation(), 
  [07:16:41.576]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.576]                   signalCondition(cond)
  [07:16:41.576]                 }
  [07:16:41.576]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.576]                 ))) {
  [07:16:41.576]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.576]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.576]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.576]                   if (!signal) {
  [07:16:41.576]                     muffleCondition <- function (cond) 
  [07:16:41.576]                     {
  [07:16:41.576]                       inherits <- base::inherits
  [07:16:41.576]                       invokeRestart <- base::invokeRestart
  [07:16:41.576]                       muffled <- FALSE
  [07:16:41.576]                       if (inherits(cond, "message")) {
  [07:16:41.576]                         invokeRestart("muffleMessage")
  [07:16:41.576]                         muffled <- TRUE
  [07:16:41.576]                       }
  [07:16:41.576]                       else if (inherits(cond, "warning")) {
  [07:16:41.576]                         invokeRestart("muffleWarning")
  [07:16:41.576]                         muffled <- TRUE
  [07:16:41.576]                       }
  [07:16:41.576]                       else if (inherits(cond, "condition")) {
  [07:16:41.576]                         computeRestarts <- base::computeRestarts
  [07:16:41.576]                         grepl <- base::grepl
  [07:16:41.576]                         is.null <- base::is.null
  [07:16:41.576]                         restarts <- computeRestarts(cond)
  [07:16:41.576]                         for (restart in restarts) {
  [07:16:41.576]                           name <- restart$name
  [07:16:41.576]                           if (is.null(name)) 
  [07:16:41.576]                             next
  [07:16:41.576]                           if (!grepl("^muffle", name)) 
  [07:16:41.576]                             next
  [07:16:41.576]                           invokeRestart(restart)
  [07:16:41.576]                           muffled <- TRUE
  [07:16:41.576]                           break
  [07:16:41.576]                         }
  [07:16:41.576]                       }
  [07:16:41.576]                       invisible(muffled)
  [07:16:41.576]                     }
  [07:16:41.576]                     muffleCondition(cond)
  [07:16:41.576]                   }
  [07:16:41.576]                 }
  [07:16:41.576]             }
  [07:16:41.576]         }))
  [07:16:41.576]     }, error = function(ex) {
  [07:16:41.576]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.576]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.576]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.576]     }, finally = {
  [07:16:41.576]         {
  [07:16:41.576]             NULL
  [07:16:41.576]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.576]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.576]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.576]                 label = NULL, ...) 
  [07:16:41.576]             {
  [07:16:41.576]                 if (substitute) 
  [07:16:41.576]                   expr <- substitute(expr)
  [07:16:41.576]                 local <- as.logical(local)
  [07:16:41.576]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.576]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.576]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.576]                   label = label, ...)
  [07:16:41.576]                 if (!future$lazy) 
  [07:16:41.576]                   future <- run(future)
  [07:16:41.576]                 invisible(future)
  [07:16:41.576]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.576]         }
  [07:16:41.576]         base::options(...future.oldOptions)
  [07:16:41.576]     })
  [07:16:41.576]     Sys.time
  [07:16:41.576]     if (base::is.na(NA)) {
  [07:16:41.576]     }
  [07:16:41.576]     else {
  [07:16:41.576]         base::sink(type = "output", split = FALSE)
  [07:16:41.576]         if (NA) {
  [07:16:41.576]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.576]         }
  [07:16:41.576]         else {
  [07:16:41.576]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.576]         }
  [07:16:41.576]         base::close(...future.stdout)
  [07:16:41.576]         ...future.stdout <- NULL
  [07:16:41.576]     }
  [07:16:41.576]     ...future.result$conditions <- ...future.conditions
  [07:16:41.576]     ...future.result
  [07:16:41.576] }
  [07:16:41.580] plan(): Setting new future strategy stack:
  [07:16:41.580] List of future strategies:
  [07:16:41.580] 1. sequential:
  [07:16:41.580]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.580]    - tweaked: FALSE
  [07:16:41.580]    - call: NULL
  [07:16:41.581] plan(): nbrOfWorkers() = 1
  [07:16:41.582] plan(): Setting new future strategy stack:
  [07:16:41.583] List of future strategies:
  [07:16:41.583] 1. sequential:
  [07:16:41.583]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.583]    - tweaked: FALSE
  [07:16:41.583]    - call: NULL
  [07:16:41.584] plan(): nbrOfWorkers() = 1
  [07:16:41.585] SequentialFuture started (and completed)
  [07:16:41.586] plan(): Setting new future strategy stack:
  [07:16:41.587] List of future strategies:
  [07:16:41.587] 1. sequential:
  [07:16:41.587]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.587]    - tweaked: FALSE
  [07:16:41.587]    - call: NULL
  [07:16:41.588] plan(): nbrOfWorkers() = 1
  [07:16:41.588] SequentialFuture started (and completed)
  [07:16:41.590] Packages needed by the future expression (n = 0): <none>
  [07:16:41.591] Packages needed by future strategies (n = 0): <none>
  [07:16:41.594] {
  [07:16:41.594]     {
  [07:16:41.594]         ...future.startTime <- base::Sys.time()
  [07:16:41.594]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.594]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.594]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.594]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.594]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.594]         {
  [07:16:41.594]             {
  [07:16:41.594]                 base::local({
  [07:16:41.594]                   has_future <- base::requireNamespace("future", 
  [07:16:41.594]                     quietly = TRUE)
  [07:16:41.594]                   version <- if (has_future) 
  [07:16:41.594]                     utils::packageVersion("future")
  [07:16:41.594]                   else NULL
  [07:16:41.594]                   if (!has_future || version < "1.8.0") {
  [07:16:41.594]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.594]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.594]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.594]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.594]                         "release", "version")], collapse = " "), 
  [07:16:41.594]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.594]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.594]                       info)
  [07:16:41.594]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.594]                     if (!has_future) {
  [07:16:41.594]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.594]                         info)
  [07:16:41.594]                     }
  [07:16:41.594]                     else {
  [07:16:41.594]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.594]                         info, version)
  [07:16:41.594]                     }
  [07:16:41.594]                     base::stop(msg)
  [07:16:41.594]                   }
  [07:16:41.594]                 })
  [07:16:41.594]             }
  [07:16:41.594]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.594]         }
  [07:16:41.594]     }
  [07:16:41.594]     if (base::is.na(NA)) {
  [07:16:41.594]     }
  [07:16:41.594]     else {
  [07:16:41.594]         if (NA) {
  [07:16:41.594]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.594]                 open = "w")
  [07:16:41.594]         }
  [07:16:41.594]         else {
  [07:16:41.594]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.594]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.594]         }
  [07:16:41.594]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.594]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.594]             base::sink(type = "output", split = FALSE)
  [07:16:41.594]             base::close(...future.stdout)
  [07:16:41.594]         }, add = TRUE)
  [07:16:41.594]     }
  [07:16:41.594]     ...future.frame <- base::sys.nframe()
  [07:16:41.594]     ...future.conditions <- base::list()
  [07:16:41.594]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.594]     ...future.result <- base::tryCatch({
  [07:16:41.594]         base::withCallingHandlers({
  [07:16:41.594]             ...future.value <- base::withVisible(base::local({
  [07:16:41.594]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.594]             }))
  [07:16:41.594]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.594]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.594]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.594]                 version = "1.8")
  [07:16:41.594]         }, condition = base::local({
  [07:16:41.594]             c <- base::c
  [07:16:41.594]             inherits <- base::inherits
  [07:16:41.594]             invokeRestart <- base::invokeRestart
  [07:16:41.594]             length <- base::length
  [07:16:41.594]             list <- base::list
  [07:16:41.594]             seq.int <- base::seq.int
  [07:16:41.594]             signalCondition <- base::signalCondition
  [07:16:41.594]             sys.calls <- base::sys.calls
  [07:16:41.594]             Sys.time <- base::Sys.time
  [07:16:41.594]             `[[` <- base::`[[`
  [07:16:41.594]             `+` <- base::`+`
  [07:16:41.594]             `<<-` <- base::`<<-`
  [07:16:41.594]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.594]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.594]                   3L)]
  [07:16:41.594]             }
  [07:16:41.594]             function(cond) {
  [07:16:41.594]                 if (inherits(cond, "error")) {
  [07:16:41.594]                   sessionInformation <- function() {
  [07:16:41.594]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.594]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.594]                       search = base::search(), system = base::Sys.info())
  [07:16:41.594]                   }
  [07:16:41.594]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.594]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.594]                     cond$call), session = sessionInformation(), 
  [07:16:41.594]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.594]                   signalCondition(cond)
  [07:16:41.594]                 }
  [07:16:41.594]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.594]                 ))) {
  [07:16:41.594]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.594]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.594]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.594]                   if (!signal) {
  [07:16:41.594]                     muffleCondition <- function (cond) 
  [07:16:41.594]                     {
  [07:16:41.594]                       inherits <- base::inherits
  [07:16:41.594]                       invokeRestart <- base::invokeRestart
  [07:16:41.594]                       muffled <- FALSE
  [07:16:41.594]                       if (inherits(cond, "message")) {
  [07:16:41.594]                         invokeRestart("muffleMessage")
  [07:16:41.594]                         muffled <- TRUE
  [07:16:41.594]                       }
  [07:16:41.594]                       else if (inherits(cond, "warning")) {
  [07:16:41.594]                         invokeRestart("muffleWarning")
  [07:16:41.594]                         muffled <- TRUE
  [07:16:41.594]                       }
  [07:16:41.594]                       else if (inherits(cond, "condition")) {
  [07:16:41.594]                         computeRestarts <- base::computeRestarts
  [07:16:41.594]                         grepl <- base::grepl
  [07:16:41.594]                         is.null <- base::is.null
  [07:16:41.594]                         restarts <- computeRestarts(cond)
  [07:16:41.594]                         for (restart in restarts) {
  [07:16:41.594]                           name <- restart$name
  [07:16:41.594]                           if (is.null(name)) 
  [07:16:41.594]                             next
  [07:16:41.594]                           if (!grepl("^muffle", name)) 
  [07:16:41.594]                             next
  [07:16:41.594]                           invokeRestart(restart)
  [07:16:41.594]                           muffled <- TRUE
  [07:16:41.594]                           break
  [07:16:41.594]                         }
  [07:16:41.594]                       }
  [07:16:41.594]                       invisible(muffled)
  [07:16:41.594]                     }
  [07:16:41.594]                     muffleCondition(cond)
  [07:16:41.594]                   }
  [07:16:41.594]                 }
  [07:16:41.594]             }
  [07:16:41.594]         }))
  [07:16:41.594]     }, error = function(ex) {
  [07:16:41.594]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.594]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.594]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.594]     }, finally = {
  [07:16:41.594]         {
  [07:16:41.594]             NULL
  [07:16:41.594]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.594]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.594]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.594]                 label = NULL, ...) 
  [07:16:41.594]             {
  [07:16:41.594]                 if (substitute) 
  [07:16:41.594]                   expr <- substitute(expr)
  [07:16:41.594]                 local <- as.logical(local)
  [07:16:41.594]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.594]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.594]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.594]                   label = label, ...)
  [07:16:41.594]                 if (!future$lazy) 
  [07:16:41.594]                   future <- run(future)
  [07:16:41.594]                 invisible(future)
  [07:16:41.594]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.594]         }
  [07:16:41.594]         base::options(...future.oldOptions)
  [07:16:41.594]     })
  [07:16:41.594]     Sys.time
  [07:16:41.594]     if (base::is.na(NA)) {
  [07:16:41.594]     }
  [07:16:41.594]     else {
  [07:16:41.594]         base::sink(type = "output", split = FALSE)
  [07:16:41.594]         if (NA) {
  [07:16:41.594]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.594]         }
  [07:16:41.594]         else {
  [07:16:41.594]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.594]         }
  [07:16:41.594]         base::close(...future.stdout)
  [07:16:41.594]         ...future.stdout <- NULL
  [07:16:41.594]     }
  [07:16:41.594]     ...future.result$conditions <- ...future.conditions
  [07:16:41.594]     ...future.result
  [07:16:41.594] }
  [07:16:41.598] plan(): Setting new future strategy stack:
  [07:16:41.599] List of future strategies:
  [07:16:41.599] 1. sequential:
  [07:16:41.599]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.599]    - tweaked: FALSE
  [07:16:41.599]    - call: NULL
  [07:16:41.600] plan(): nbrOfWorkers() = 1
  [07:16:41.601] plan(): Setting new future strategy stack:
  [07:16:41.601] List of future strategies:
  [07:16:41.601] 1. sequential:
  [07:16:41.601]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.601]    - tweaked: FALSE
  [07:16:41.601]    - call: NULL
  [07:16:41.602] plan(): nbrOfWorkers() = 1
  [07:16:41.603] SequentialFuture started (and completed)
  [07:16:41.604] plan(): Setting new future strategy stack:
  [07:16:41.604] List of future strategies:
  [07:16:41.604] 1. sequential:
  [07:16:41.604]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.604]    - tweaked: FALSE
  [07:16:41.604]    - call: NULL
  [07:16:41.605] plan(): nbrOfWorkers() = 1
  [07:16:41.606] SequentialFuture started (and completed)
  [07:16:41.608] Packages needed by the future expression (n = 0): <none>
  [07:16:41.608] Packages needed by future strategies (n = 0): <none>
  [07:16:41.612] {
  [07:16:41.612]     {
  [07:16:41.612]         ...future.startTime <- base::Sys.time()
  [07:16:41.612]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.612]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.612]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.612]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.612]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.612]         {
  [07:16:41.612]             {
  [07:16:41.612]                 base::local({
  [07:16:41.612]                   has_future <- base::requireNamespace("future", 
  [07:16:41.612]                     quietly = TRUE)
  [07:16:41.612]                   version <- if (has_future) 
  [07:16:41.612]                     utils::packageVersion("future")
  [07:16:41.612]                   else NULL
  [07:16:41.612]                   if (!has_future || version < "1.8.0") {
  [07:16:41.612]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.612]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.612]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.612]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.612]                         "release", "version")], collapse = " "), 
  [07:16:41.612]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.612]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.612]                       info)
  [07:16:41.612]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.612]                     if (!has_future) {
  [07:16:41.612]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.612]                         info)
  [07:16:41.612]                     }
  [07:16:41.612]                     else {
  [07:16:41.612]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.612]                         info, version)
  [07:16:41.612]                     }
  [07:16:41.612]                     base::stop(msg)
  [07:16:41.612]                   }
  [07:16:41.612]                 })
  [07:16:41.612]             }
  [07:16:41.612]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.612]         }
  [07:16:41.612]     }
  [07:16:41.612]     if (base::is.na(NA)) {
  [07:16:41.612]     }
  [07:16:41.612]     else {
  [07:16:41.612]         if (NA) {
  [07:16:41.612]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.612]                 open = "w")
  [07:16:41.612]         }
  [07:16:41.612]         else {
  [07:16:41.612]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.612]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.612]         }
  [07:16:41.612]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.612]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.612]             base::sink(type = "output", split = FALSE)
  [07:16:41.612]             base::close(...future.stdout)
  [07:16:41.612]         }, add = TRUE)
  [07:16:41.612]     }
  [07:16:41.612]     ...future.frame <- base::sys.nframe()
  [07:16:41.612]     ...future.conditions <- base::list()
  [07:16:41.612]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.612]     ...future.result <- base::tryCatch({
  [07:16:41.612]         base::withCallingHandlers({
  [07:16:41.612]             ...future.value <- base::withVisible(base::local({
  [07:16:41.612]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.612]             }))
  [07:16:41.612]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.612]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.612]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.612]                 version = "1.8")
  [07:16:41.612]         }, condition = base::local({
  [07:16:41.612]             c <- base::c
  [07:16:41.612]             inherits <- base::inherits
  [07:16:41.612]             invokeRestart <- base::invokeRestart
  [07:16:41.612]             length <- base::length
  [07:16:41.612]             list <- base::list
  [07:16:41.612]             seq.int <- base::seq.int
  [07:16:41.612]             signalCondition <- base::signalCondition
  [07:16:41.612]             sys.calls <- base::sys.calls
  [07:16:41.612]             Sys.time <- base::Sys.time
  [07:16:41.612]             `[[` <- base::`[[`
  [07:16:41.612]             `+` <- base::`+`
  [07:16:41.612]             `<<-` <- base::`<<-`
  [07:16:41.612]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.612]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.612]                   3L)]
  [07:16:41.612]             }
  [07:16:41.612]             function(cond) {
  [07:16:41.612]                 if (inherits(cond, "error")) {
  [07:16:41.612]                   sessionInformation <- function() {
  [07:16:41.612]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.612]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.612]                       search = base::search(), system = base::Sys.info())
  [07:16:41.612]                   }
  [07:16:41.612]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.612]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.612]                     cond$call), session = sessionInformation(), 
  [07:16:41.612]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.612]                   signalCondition(cond)
  [07:16:41.612]                 }
  [07:16:41.612]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.612]                 ))) {
  [07:16:41.612]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.612]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.612]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.612]                   if (!signal) {
  [07:16:41.612]                     muffleCondition <- function (cond) 
  [07:16:41.612]                     {
  [07:16:41.612]                       inherits <- base::inherits
  [07:16:41.612]                       invokeRestart <- base::invokeRestart
  [07:16:41.612]                       muffled <- FALSE
  [07:16:41.612]                       if (inherits(cond, "message")) {
  [07:16:41.612]                         invokeRestart("muffleMessage")
  [07:16:41.612]                         muffled <- TRUE
  [07:16:41.612]                       }
  [07:16:41.612]                       else if (inherits(cond, "warning")) {
  [07:16:41.612]                         invokeRestart("muffleWarning")
  [07:16:41.612]                         muffled <- TRUE
  [07:16:41.612]                       }
  [07:16:41.612]                       else if (inherits(cond, "condition")) {
  [07:16:41.612]                         computeRestarts <- base::computeRestarts
  [07:16:41.612]                         grepl <- base::grepl
  [07:16:41.612]                         is.null <- base::is.null
  [07:16:41.612]                         restarts <- computeRestarts(cond)
  [07:16:41.612]                         for (restart in restarts) {
  [07:16:41.612]                           name <- restart$name
  [07:16:41.612]                           if (is.null(name)) 
  [07:16:41.612]                             next
  [07:16:41.612]                           if (!grepl("^muffle", name)) 
  [07:16:41.612]                             next
  [07:16:41.612]                           invokeRestart(restart)
  [07:16:41.612]                           muffled <- TRUE
  [07:16:41.612]                           break
  [07:16:41.612]                         }
  [07:16:41.612]                       }
  [07:16:41.612]                       invisible(muffled)
  [07:16:41.612]                     }
  [07:16:41.612]                     muffleCondition(cond)
  [07:16:41.612]                   }
  [07:16:41.612]                 }
  [07:16:41.612]             }
  [07:16:41.612]         }))
  [07:16:41.612]     }, error = function(ex) {
  [07:16:41.612]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.612]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.612]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.612]     }, finally = {
  [07:16:41.612]         {
  [07:16:41.612]             NULL
  [07:16:41.612]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.612]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.612]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.612]                 label = NULL, ...) 
  [07:16:41.612]             {
  [07:16:41.612]                 if (substitute) 
  [07:16:41.612]                   expr <- substitute(expr)
  [07:16:41.612]                 local <- as.logical(local)
  [07:16:41.612]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.612]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.612]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.612]                   label = label, ...)
  [07:16:41.612]                 if (!future$lazy) 
  [07:16:41.612]                   future <- run(future)
  [07:16:41.612]                 invisible(future)
  [07:16:41.612]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.612]         }
  [07:16:41.612]         base::options(...future.oldOptions)
  [07:16:41.612]     })
  [07:16:41.612]     Sys.time
  [07:16:41.612]     if (base::is.na(NA)) {
  [07:16:41.612]     }
  [07:16:41.612]     else {
  [07:16:41.612]         base::sink(type = "output", split = FALSE)
  [07:16:41.612]         if (NA) {
  [07:16:41.612]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.612]         }
  [07:16:41.612]         else {
  [07:16:41.612]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.612]         }
  [07:16:41.612]         base::close(...future.stdout)
  [07:16:41.612]         ...future.stdout <- NULL
  [07:16:41.612]     }
  [07:16:41.612]     ...future.result$conditions <- ...future.conditions
  [07:16:41.612]     ...future.result
  [07:16:41.612] }
  [07:16:41.615] plan(): Setting new future strategy stack:
  [07:16:41.616] List of future strategies:
  [07:16:41.616] 1. sequential:
  [07:16:41.616]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.616]    - tweaked: FALSE
  [07:16:41.616]    - call: NULL
  [07:16:41.617] plan(): nbrOfWorkers() = 1
  [07:16:41.618] plan(): Setting new future strategy stack:
  [07:16:41.619] List of future strategies:
  [07:16:41.619] 1. sequential:
  [07:16:41.619]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.619]    - tweaked: FALSE
  [07:16:41.619]    - call: NULL
  [07:16:41.620] plan(): nbrOfWorkers() = 1
  [07:16:41.620] SequentialFuture started (and completed)
  [07:16:41.623] plan(): Setting new future strategy stack:
  [07:16:41.623] List of future strategies:
  [07:16:41.623] 1. sequential:
  [07:16:41.623]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.623]    - tweaked: FALSE
  [07:16:41.623]    - call: NULL
  [07:16:41.624] plan(): nbrOfWorkers() = 1
  [07:16:41.625] SequentialFuture started (and completed)
  [07:16:41.627] Packages needed by the future expression (n = 0): <none>
  [07:16:41.627] Packages needed by future strategies (n = 0): <none>
  [07:16:41.631] {
  [07:16:41.631]     {
  [07:16:41.631]         ...future.startTime <- base::Sys.time()
  [07:16:41.631]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.631]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.631]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.631]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.631]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.631]         {
  [07:16:41.631]             {
  [07:16:41.631]                 base::local({
  [07:16:41.631]                   has_future <- base::requireNamespace("future", 
  [07:16:41.631]                     quietly = TRUE)
  [07:16:41.631]                   version <- if (has_future) 
  [07:16:41.631]                     utils::packageVersion("future")
  [07:16:41.631]                   else NULL
  [07:16:41.631]                   if (!has_future || version < "1.8.0") {
  [07:16:41.631]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.631]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.631]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.631]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.631]                         "release", "version")], collapse = " "), 
  [07:16:41.631]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.631]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.631]                       info)
  [07:16:41.631]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.631]                     if (!has_future) {
  [07:16:41.631]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.631]                         info)
  [07:16:41.631]                     }
  [07:16:41.631]                     else {
  [07:16:41.631]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.631]                         info, version)
  [07:16:41.631]                     }
  [07:16:41.631]                     base::stop(msg)
  [07:16:41.631]                   }
  [07:16:41.631]                 })
  [07:16:41.631]             }
  [07:16:41.631]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.631]         }
  [07:16:41.631]     }
  [07:16:41.631]     if (base::is.na(NA)) {
  [07:16:41.631]     }
  [07:16:41.631]     else {
  [07:16:41.631]         if (NA) {
  [07:16:41.631]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.631]                 open = "w")
  [07:16:41.631]         }
  [07:16:41.631]         else {
  [07:16:41.631]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.631]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.631]         }
  [07:16:41.631]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.631]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.631]             base::sink(type = "output", split = FALSE)
  [07:16:41.631]             base::close(...future.stdout)
  [07:16:41.631]         }, add = TRUE)
  [07:16:41.631]     }
  [07:16:41.631]     ...future.frame <- base::sys.nframe()
  [07:16:41.631]     ...future.conditions <- base::list()
  [07:16:41.631]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.631]     ...future.result <- base::tryCatch({
  [07:16:41.631]         base::withCallingHandlers({
  [07:16:41.631]             ...future.value <- base::withVisible(base::local({
  [07:16:41.631]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.631]             }))
  [07:16:41.631]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.631]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.631]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.631]                 version = "1.8")
  [07:16:41.631]         }, condition = base::local({
  [07:16:41.631]             c <- base::c
  [07:16:41.631]             inherits <- base::inherits
  [07:16:41.631]             invokeRestart <- base::invokeRestart
  [07:16:41.631]             length <- base::length
  [07:16:41.631]             list <- base::list
  [07:16:41.631]             seq.int <- base::seq.int
  [07:16:41.631]             signalCondition <- base::signalCondition
  [07:16:41.631]             sys.calls <- base::sys.calls
  [07:16:41.631]             Sys.time <- base::Sys.time
  [07:16:41.631]             `[[` <- base::`[[`
  [07:16:41.631]             `+` <- base::`+`
  [07:16:41.631]             `<<-` <- base::`<<-`
  [07:16:41.631]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.631]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.631]                   3L)]
  [07:16:41.631]             }
  [07:16:41.631]             function(cond) {
  [07:16:41.631]                 if (inherits(cond, "error")) {
  [07:16:41.631]                   sessionInformation <- function() {
  [07:16:41.631]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.631]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.631]                       search = base::search(), system = base::Sys.info())
  [07:16:41.631]                   }
  [07:16:41.631]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.631]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.631]                     cond$call), session = sessionInformation(), 
  [07:16:41.631]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.631]                   signalCondition(cond)
  [07:16:41.631]                 }
  [07:16:41.631]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.631]                 ))) {
  [07:16:41.631]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.631]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.631]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.631]                   if (!signal) {
  [07:16:41.631]                     muffleCondition <- function (cond) 
  [07:16:41.631]                     {
  [07:16:41.631]                       inherits <- base::inherits
  [07:16:41.631]                       invokeRestart <- base::invokeRestart
  [07:16:41.631]                       muffled <- FALSE
  [07:16:41.631]                       if (inherits(cond, "message")) {
  [07:16:41.631]                         invokeRestart("muffleMessage")
  [07:16:41.631]                         muffled <- TRUE
  [07:16:41.631]                       }
  [07:16:41.631]                       else if (inherits(cond, "warning")) {
  [07:16:41.631]                         invokeRestart("muffleWarning")
  [07:16:41.631]                         muffled <- TRUE
  [07:16:41.631]                       }
  [07:16:41.631]                       else if (inherits(cond, "condition")) {
  [07:16:41.631]                         computeRestarts <- base::computeRestarts
  [07:16:41.631]                         grepl <- base::grepl
  [07:16:41.631]                         is.null <- base::is.null
  [07:16:41.631]                         restarts <- computeRestarts(cond)
  [07:16:41.631]                         for (restart in restarts) {
  [07:16:41.631]                           name <- restart$name
  [07:16:41.631]                           if (is.null(name)) 
  [07:16:41.631]                             next
  [07:16:41.631]                           if (!grepl("^muffle", name)) 
  [07:16:41.631]                             next
  [07:16:41.631]                           invokeRestart(restart)
  [07:16:41.631]                           muffled <- TRUE
  [07:16:41.631]                           break
  [07:16:41.631]                         }
  [07:16:41.631]                       }
  [07:16:41.631]                       invisible(muffled)
  [07:16:41.631]                     }
  [07:16:41.631]                     muffleCondition(cond)
  [07:16:41.631]                   }
  [07:16:41.631]                 }
  [07:16:41.631]             }
  [07:16:41.631]         }))
  [07:16:41.631]     }, error = function(ex) {
  [07:16:41.631]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.631]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.631]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.631]     }, finally = {
  [07:16:41.631]         {
  [07:16:41.631]             NULL
  [07:16:41.631]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.631]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.631]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.631]                 label = NULL, ...) 
  [07:16:41.631]             {
  [07:16:41.631]                 if (substitute) 
  [07:16:41.631]                   expr <- substitute(expr)
  [07:16:41.631]                 local <- as.logical(local)
  [07:16:41.631]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.631]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.631]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.631]                   label = label, ...)
  [07:16:41.631]                 if (!future$lazy) 
  [07:16:41.631]                   future <- run(future)
  [07:16:41.631]                 invisible(future)
  [07:16:41.631]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.631]         }
  [07:16:41.631]         base::options(...future.oldOptions)
  [07:16:41.631]     })
  [07:16:41.631]     Sys.time
  [07:16:41.631]     if (base::is.na(NA)) {
  [07:16:41.631]     }
  [07:16:41.631]     else {
  [07:16:41.631]         base::sink(type = "output", split = FALSE)
  [07:16:41.631]         if (NA) {
  [07:16:41.631]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.631]         }
  [07:16:41.631]         else {
  [07:16:41.631]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.631]         }
  [07:16:41.631]         base::close(...future.stdout)
  [07:16:41.631]         ...future.stdout <- NULL
  [07:16:41.631]     }
  [07:16:41.631]     ...future.result$conditions <- ...future.conditions
  [07:16:41.631]     ...future.result
  [07:16:41.631] }
  [07:16:41.634] plan(): Setting new future strategy stack:
  [07:16:41.635] List of future strategies:
  [07:16:41.635] 1. sequential:
  [07:16:41.635]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.635]    - tweaked: FALSE
  [07:16:41.635]    - call: NULL
  [07:16:41.636] plan(): nbrOfWorkers() = 1
  [07:16:41.637] plan(): Setting new future strategy stack:
  [07:16:41.637] List of future strategies:
  [07:16:41.637] 1. sequential:
  [07:16:41.637]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.637]    - tweaked: FALSE
  [07:16:41.637]    - call: NULL
  [07:16:41.638] plan(): nbrOfWorkers() = 1
  [07:16:41.639] SequentialFuture started (and completed)
  [07:16:41.640] plan(): Setting new future strategy stack:
  [07:16:41.640] List of future strategies:
  [07:16:41.640] 1. sequential:
  [07:16:41.640]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.640]    - tweaked: FALSE
  [07:16:41.640]    - call: NULL
  [07:16:41.641] plan(): nbrOfWorkers() = 1
  [07:16:41.641] SequentialFuture started (and completed)
  [07:16:41.643] Packages needed by the future expression (n = 0): <none>
  [07:16:41.643] Packages needed by future strategies (n = 0): <none>
  [07:16:41.646] {
  [07:16:41.646]     {
  [07:16:41.646]         ...future.startTime <- base::Sys.time()
  [07:16:41.646]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.646]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.646]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.646]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.646]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.646]         {
  [07:16:41.646]             {
  [07:16:41.646]                 base::local({
  [07:16:41.646]                   has_future <- base::requireNamespace("future", 
  [07:16:41.646]                     quietly = TRUE)
  [07:16:41.646]                   version <- if (has_future) 
  [07:16:41.646]                     utils::packageVersion("future")
  [07:16:41.646]                   else NULL
  [07:16:41.646]                   if (!has_future || version < "1.8.0") {
  [07:16:41.646]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.646]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.646]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.646]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.646]                         "release", "version")], collapse = " "), 
  [07:16:41.646]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.646]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.646]                       info)
  [07:16:41.646]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.646]                     if (!has_future) {
  [07:16:41.646]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.646]                         info)
  [07:16:41.646]                     }
  [07:16:41.646]                     else {
  [07:16:41.646]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.646]                         info, version)
  [07:16:41.646]                     }
  [07:16:41.646]                     base::stop(msg)
  [07:16:41.646]                   }
  [07:16:41.646]                 })
  [07:16:41.646]             }
  [07:16:41.646]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.646]         }
  [07:16:41.646]     }
  [07:16:41.646]     if (base::is.na(NA)) {
  [07:16:41.646]     }
  [07:16:41.646]     else {
  [07:16:41.646]         if (NA) {
  [07:16:41.646]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.646]                 open = "w")
  [07:16:41.646]         }
  [07:16:41.646]         else {
  [07:16:41.646]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.646]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.646]         }
  [07:16:41.646]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.646]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.646]             base::sink(type = "output", split = FALSE)
  [07:16:41.646]             base::close(...future.stdout)
  [07:16:41.646]         }, add = TRUE)
  [07:16:41.646]     }
  [07:16:41.646]     ...future.frame <- base::sys.nframe()
  [07:16:41.646]     ...future.conditions <- base::list()
  [07:16:41.646]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.646]     ...future.result <- base::tryCatch({
  [07:16:41.646]         base::withCallingHandlers({
  [07:16:41.646]             ...future.value <- base::withVisible(base::local({
  [07:16:41.646]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.646]             }))
  [07:16:41.646]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.646]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.646]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.646]                 version = "1.8")
  [07:16:41.646]         }, condition = base::local({
  [07:16:41.646]             c <- base::c
  [07:16:41.646]             inherits <- base::inherits
  [07:16:41.646]             invokeRestart <- base::invokeRestart
  [07:16:41.646]             length <- base::length
  [07:16:41.646]             list <- base::list
  [07:16:41.646]             seq.int <- base::seq.int
  [07:16:41.646]             signalCondition <- base::signalCondition
  [07:16:41.646]             sys.calls <- base::sys.calls
  [07:16:41.646]             Sys.time <- base::Sys.time
  [07:16:41.646]             `[[` <- base::`[[`
  [07:16:41.646]             `+` <- base::`+`
  [07:16:41.646]             `<<-` <- base::`<<-`
  [07:16:41.646]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.646]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.646]                   3L)]
  [07:16:41.646]             }
  [07:16:41.646]             function(cond) {
  [07:16:41.646]                 if (inherits(cond, "error")) {
  [07:16:41.646]                   sessionInformation <- function() {
  [07:16:41.646]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.646]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.646]                       search = base::search(), system = base::Sys.info())
  [07:16:41.646]                   }
  [07:16:41.646]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.646]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.646]                     cond$call), session = sessionInformation(), 
  [07:16:41.646]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.646]                   signalCondition(cond)
  [07:16:41.646]                 }
  [07:16:41.646]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.646]                 ))) {
  [07:16:41.646]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.646]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.646]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.646]                   if (!signal) {
  [07:16:41.646]                     muffleCondition <- function (cond) 
  [07:16:41.646]                     {
  [07:16:41.646]                       inherits <- base::inherits
  [07:16:41.646]                       invokeRestart <- base::invokeRestart
  [07:16:41.646]                       muffled <- FALSE
  [07:16:41.646]                       if (inherits(cond, "message")) {
  [07:16:41.646]                         invokeRestart("muffleMessage")
  [07:16:41.646]                         muffled <- TRUE
  [07:16:41.646]                       }
  [07:16:41.646]                       else if (inherits(cond, "warning")) {
  [07:16:41.646]                         invokeRestart("muffleWarning")
  [07:16:41.646]                         muffled <- TRUE
  [07:16:41.646]                       }
  [07:16:41.646]                       else if (inherits(cond, "condition")) {
  [07:16:41.646]                         computeRestarts <- base::computeRestarts
  [07:16:41.646]                         grepl <- base::grepl
  [07:16:41.646]                         is.null <- base::is.null
  [07:16:41.646]                         restarts <- computeRestarts(cond)
  [07:16:41.646]                         for (restart in restarts) {
  [07:16:41.646]                           name <- restart$name
  [07:16:41.646]                           if (is.null(name)) 
  [07:16:41.646]                             next
  [07:16:41.646]                           if (!grepl("^muffle", name)) 
  [07:16:41.646]                             next
  [07:16:41.646]                           invokeRestart(restart)
  [07:16:41.646]                           muffled <- TRUE
  [07:16:41.646]                           break
  [07:16:41.646]                         }
  [07:16:41.646]                       }
  [07:16:41.646]                       invisible(muffled)
  [07:16:41.646]                     }
  [07:16:41.646]                     muffleCondition(cond)
  [07:16:41.646]                   }
  [07:16:41.646]                 }
  [07:16:41.646]             }
  [07:16:41.646]         }))
  [07:16:41.646]     }, error = function(ex) {
  [07:16:41.646]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.646]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.646]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.646]     }, finally = {
  [07:16:41.646]         {
  [07:16:41.646]             NULL
  [07:16:41.646]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.646]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.646]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.646]                 label = NULL, ...) 
  [07:16:41.646]             {
  [07:16:41.646]                 if (substitute) 
  [07:16:41.646]                   expr <- substitute(expr)
  [07:16:41.646]                 local <- as.logical(local)
  [07:16:41.646]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.646]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.646]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.646]                   label = label, ...)
  [07:16:41.646]                 if (!future$lazy) 
  [07:16:41.646]                   future <- run(future)
  [07:16:41.646]                 invisible(future)
  [07:16:41.646]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.646]         }
  [07:16:41.646]         base::options(...future.oldOptions)
  [07:16:41.646]     })
  [07:16:41.646]     Sys.time
  [07:16:41.646]     if (base::is.na(NA)) {
  [07:16:41.646]     }
  [07:16:41.646]     else {
  [07:16:41.646]         base::sink(type = "output", split = FALSE)
  [07:16:41.646]         if (NA) {
  [07:16:41.646]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.646]         }
  [07:16:41.646]         else {
  [07:16:41.646]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.646]         }
  [07:16:41.646]         base::close(...future.stdout)
  [07:16:41.646]         ...future.stdout <- NULL
  [07:16:41.646]     }
  [07:16:41.646]     ...future.result$conditions <- ...future.conditions
  [07:16:41.646]     ...future.result
  [07:16:41.646] }
  [07:16:41.650] plan(): Setting new future strategy stack:
  [07:16:41.650] List of future strategies:
  [07:16:41.650] 1. sequential:
  [07:16:41.650]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.650]    - tweaked: FALSE
  [07:16:41.650]    - call: NULL
  [07:16:41.651] plan(): nbrOfWorkers() = 1
  [07:16:41.652] plan(): Setting new future strategy stack:
  [07:16:41.652] List of future strategies:
  [07:16:41.652] 1. sequential:
  [07:16:41.652]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.652]    - tweaked: FALSE
  [07:16:41.652]    - call: NULL
  [07:16:41.653] plan(): nbrOfWorkers() = 1
  [07:16:41.654] SequentialFuture started (and completed)
  [07:16:41.654] plan(): Setting new future strategy stack:
  [07:16:41.655] List of future strategies:
  [07:16:41.655] 1. sequential:
  [07:16:41.655]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.655]    - tweaked: FALSE
  [07:16:41.655]    - call: NULL
  [07:16:41.655] plan(): nbrOfWorkers() = 1
  [07:16:41.656] SequentialFuture started (and completed)
  [07:16:41.657] Packages needed by the future expression (n = 0): <none>
  [07:16:41.658] Packages needed by future strategies (n = 0): <none>
  [07:16:41.661] {
  [07:16:41.661]     {
  [07:16:41.661]         ...future.startTime <- base::Sys.time()
  [07:16:41.661]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.661]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.661]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.661]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.661]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.661]         {
  [07:16:41.661]             {
  [07:16:41.661]                 base::local({
  [07:16:41.661]                   has_future <- base::requireNamespace("future", 
  [07:16:41.661]                     quietly = TRUE)
  [07:16:41.661]                   version <- if (has_future) 
  [07:16:41.661]                     utils::packageVersion("future")
  [07:16:41.661]                   else NULL
  [07:16:41.661]                   if (!has_future || version < "1.8.0") {
  [07:16:41.661]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.661]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.661]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.661]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.661]                         "release", "version")], collapse = " "), 
  [07:16:41.661]                       hostname = base::Sys.info()[["nodename"]])
  [07:16:41.661]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.661]                       info)
  [07:16:41.661]                     info <- base::paste(info, collapse = "; ")
  [07:16:41.661]                     if (!has_future) {
  [07:16:41.661]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.661]                         info)
  [07:16:41.661]                     }
  [07:16:41.661]                     else {
  [07:16:41.661]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.661]                         info, version)
  [07:16:41.661]                     }
  [07:16:41.661]                     base::stop(msg)
  [07:16:41.661]                   }
  [07:16:41.661]                 })
  [07:16:41.661]             }
  [07:16:41.661]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.661]         }
  [07:16:41.661]     }
  [07:16:41.661]     if (base::is.na(NA)) {
  [07:16:41.661]     }
  [07:16:41.661]     else {
  [07:16:41.661]         if (NA) {
  [07:16:41.661]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.661]                 open = "w")
  [07:16:41.661]         }
  [07:16:41.661]         else {
  [07:16:41.661]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.661]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.661]         }
  [07:16:41.661]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.661]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.661]             base::sink(type = "output", split = FALSE)
  [07:16:41.661]             base::close(...future.stdout)
  [07:16:41.661]         }, add = TRUE)
  [07:16:41.661]     }
  [07:16:41.661]     ...future.frame <- base::sys.nframe()
  [07:16:41.661]     ...future.conditions <- base::list()
  [07:16:41.661]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.661]     ...future.result <- base::tryCatch({
  [07:16:41.661]         base::withCallingHandlers({
  [07:16:41.661]             ...future.value <- base::withVisible(base::local({
  [07:16:41.661]                 x[[i - 2]] + x[[i - 1]]
  [07:16:41.661]             }))
  [07:16:41.661]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.661]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.661]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.661]                 version = "1.8")
  [07:16:41.661]         }, condition = base::local({
  [07:16:41.661]             c <- base::c
  [07:16:41.661]             inherits <- base::inherits
  [07:16:41.661]             invokeRestart <- base::invokeRestart
  [07:16:41.661]             length <- base::length
  [07:16:41.661]             list <- base::list
  [07:16:41.661]             seq.int <- base::seq.int
  [07:16:41.661]             signalCondition <- base::signalCondition
  [07:16:41.661]             sys.calls <- base::sys.calls
  [07:16:41.661]             Sys.time <- base::Sys.time
  [07:16:41.661]             `[[` <- base::`[[`
  [07:16:41.661]             `+` <- base::`+`
  [07:16:41.661]             `<<-` <- base::`<<-`
  [07:16:41.661]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.661]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.661]                   3L)]
  [07:16:41.661]             }
  [07:16:41.661]             function(cond) {
  [07:16:41.661]                 if (inherits(cond, "error")) {
  [07:16:41.661]                   sessionInformation <- function() {
  [07:16:41.661]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.661]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.661]                       search = base::search(), system = base::Sys.info())
  [07:16:41.661]                   }
  [07:16:41.661]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.661]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.661]                     cond$call), session = sessionInformation(), 
  [07:16:41.661]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.661]                   signalCondition(cond)
  [07:16:41.661]                 }
  [07:16:41.661]                 else if (inherits(cond, c("error", "immediateCondition"
  [07:16:41.661]                 ))) {
  [07:16:41.661]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.661]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.661]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.661]                   if (!signal) {
  [07:16:41.661]                     muffleCondition <- function (cond) 
  [07:16:41.661]                     {
  [07:16:41.661]                       inherits <- base::inherits
  [07:16:41.661]                       invokeRestart <- base::invokeRestart
  [07:16:41.661]                       muffled <- FALSE
  [07:16:41.661]                       if (inherits(cond, "message")) {
  [07:16:41.661]                         invokeRestart("muffleMessage")
  [07:16:41.661]                         muffled <- TRUE
  [07:16:41.661]                       }
  [07:16:41.661]                       else if (inherits(cond, "warning")) {
  [07:16:41.661]                         invokeRestart("muffleWarning")
  [07:16:41.661]                         muffled <- TRUE
  [07:16:41.661]                       }
  [07:16:41.661]                       else if (inherits(cond, "condition")) {
  [07:16:41.661]                         computeRestarts <- base::computeRestarts
  [07:16:41.661]                         grepl <- base::grepl
  [07:16:41.661]                         is.null <- base::is.null
  [07:16:41.661]                         restarts <- computeRestarts(cond)
  [07:16:41.661]                         for (restart in restarts) {
  [07:16:41.661]                           name <- restart$name
  [07:16:41.661]                           if (is.null(name)) 
  [07:16:41.661]                             next
  [07:16:41.661]                           if (!grepl("^muffle", name)) 
  [07:16:41.661]                             next
  [07:16:41.661]                           invokeRestart(restart)
  [07:16:41.661]                           muffled <- TRUE
  [07:16:41.661]                           break
  [07:16:41.661]                         }
  [07:16:41.661]                       }
  [07:16:41.661]                       invisible(muffled)
  [07:16:41.661]                     }
  [07:16:41.661]                     muffleCondition(cond)
  [07:16:41.661]                   }
  [07:16:41.661]                 }
  [07:16:41.661]             }
  [07:16:41.661]         }))
  [07:16:41.661]     }, error = function(ex) {
  [07:16:41.661]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.661]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.661]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.661]     }, finally = {
  [07:16:41.661]         {
  [07:16:41.661]             NULL
  [07:16:41.661]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.661]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.661]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.661]                 label = NULL, ...) 
  [07:16:41.661]             {
  [07:16:41.661]                 if (substitute) 
  [07:16:41.661]                   expr <- substitute(expr)
  [07:16:41.661]                 local <- as.logical(local)
  [07:16:41.661]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.661]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.661]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.661]                   label = label, ...)
  [07:16:41.661]                 if (!future$lazy) 
  [07:16:41.661]                   future <- run(future)
  [07:16:41.661]                 invisible(future)
  [07:16:41.661]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.661]         }
  [07:16:41.661]         base::options(...future.oldOptions)
  [07:16:41.661]     })
  [07:16:41.661]     Sys.time
  [07:16:41.661]     if (base::is.na(NA)) {
  [07:16:41.661]     }
  [07:16:41.661]     else {
  [07:16:41.661]         base::sink(type = "output", split = FALSE)
  [07:16:41.661]         if (NA) {
  [07:16:41.661]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.661]         }
  [07:16:41.661]         else {
  [07:16:41.661]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.661]         }
  [07:16:41.661]         base::close(...future.stdout)
  [07:16:41.661]         ...future.stdout <- NULL
  [07:16:41.661]     }
  [07:16:41.661]     ...future.result$conditions <- ...future.conditions
  [07:16:41.661]     ...future.result
  [07:16:41.661] }
  [07:16:41.664] plan(): Setting new future strategy stack:
  [07:16:41.665] List of future strategies:
  [07:16:41.665] 1. sequential:
  [07:16:41.665]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.665]    - tweaked: FALSE
  [07:16:41.665]    - call: NULL
  [07:16:41.665] plan(): nbrOfWorkers() = 1
  [07:16:41.666] plan(): Setting new future strategy stack:
  [07:16:41.666] List of future strategies:
  [07:16:41.666] 1. sequential:
  [07:16:41.666]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.666]    - tweaked: FALSE
  [07:16:41.666]    - call: NULL
  [07:16:41.667] plan(): nbrOfWorkers() = 1
  [07:16:41.668] SequentialFuture started (and completed)
  [07:16:41.668] plan(): Setting new future strategy stack:
  [07:16:41.668] List of future strategies:
  [07:16:41.668] 1. sequential:
  [07:16:41.668]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.668]    - tweaked: FALSE
  [07:16:41.668]    - call: plan(sequential)
  [07:16:41.669] plan(): nbrOfWorkers() = 1
  [07:16:41.669] SequentialFuture started (and completed)
  [1] 7778742049
  
  > ## Reset plan
  > plan(oplan)
  [07:16:41.670] plan(): Setting new future strategy stack:
  [07:16:41.670] List of future strategies:
  [07:16:41.670] 1. sequential:
  [07:16:41.670]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.670]    - tweaked: FALSE
  [07:16:41.670]    - call: future::plan("sequential")
  [07:16:41.671] 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:16:41.685] plan(): Setting new future strategy stack:
  [07:16:41.685] List of future strategies:
  [07:16:41.685] 1. sequential:
  [07:16:41.685]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.685]    - tweaked: FALSE
  [07:16:41.685]    - call: plan(strategy)
  [07:16:41.686] 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:16:41.736] getGlobalsAndPackages() ...
  [07:16:41.736] Searching for globals...
  [07:16:41.741] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:16:41.742] Searching for globals ... DONE
  [07:16:41.742] Resolving globals: FALSE
  [07:16:41.743] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:16:41.743] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:16:41.744] - packages: [1] 'future'
  [07:16:41.744] getGlobalsAndPackages() ... DONE
   2[07:16:41.751] getGlobalsAndPackages() ...
  [07:16:41.751] Searching for globals...
  [07:16:41.755] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:16:41.755] Searching for globals ... DONE
  [07:16:41.755] Resolving globals: FALSE
  [07:16:41.759] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:16:41.759] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:16:41.759] - packages: [1] 'future'
  [07:16:41.760] getGlobalsAndPackages() ... DONE
   3[07:16:41.760] getGlobalsAndPackages() ...
  [07:16:41.760] Searching for globals...
  [07:16:41.765] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:16:41.765] Searching for globals ... DONE
  [07:16:41.765] Resolving globals: FALSE
  [07:16:41.766] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:16:41.766] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:16:41.767] - packages: [1] 'future'
  [07:16:41.767] getGlobalsAndPackages() ... DONE
   4[07:16:41.768] getGlobalsAndPackages() ...
  [07:16:41.768] Searching for globals...
  [07:16:41.772] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:16:41.772] Searching for globals ... DONE
  [07:16:41.772] Resolving globals: FALSE
  [07:16:41.773] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:16:41.773] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:16:41.774] - packages: [1] 'future'
  [07:16:41.774] getGlobalsAndPackages() ... DONE
  
  > message(".")
  .
  
  > ## Calculate and plot tiles
  > repeat {
  +   counts <- plot_what_is_done(counts)
  +   if (!any(sapply(counts, FUN = inherits, "Future"))) break
  + }
  [07:16:41.790] Packages needed by the future expression (n = 1): 'future'
  [07:16:41.791] Packages needed by future strategies (n = 0): <none>
  [07:16:41.796] {
  [07:16:41.796]     {
  [07:16:41.796]         ...future.startTime <- base::Sys.time()
  [07:16:41.796]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.796]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.796]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.796]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.796]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.796]         {
  [07:16:41.796]             {
  [07:16:41.796]                 {
  [07:16:41.796]                   base::local({
  [07:16:41.796]                     has_future <- base::requireNamespace("future", 
  [07:16:41.796]                       quietly = TRUE)
  [07:16:41.796]                     version <- if (has_future) 
  [07:16:41.796]                       utils::packageVersion("future")
  [07:16:41.796]                     else NULL
  [07:16:41.796]                     if (!has_future || version < "1.8.0") {
  [07:16:41.796]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.796]                         "", base::R.version$version.string), 
  [07:16:41.796]                         platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.796]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.796]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.796]                           "release", "version")], collapse = " "), 
  [07:16:41.796]                         hostname = base::Sys.info()[["nodename"]])
  [07:16:41.796]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.796]                         info)
  [07:16:41.796]                       info <- base::paste(info, collapse = "; ")
  [07:16:41.796]                       if (!has_future) {
  [07:16:41.796]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.796]                           info)
  [07:16:41.796]                       }
  [07:16:41.796]                       else {
  [07:16:41.796]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.796]                           info, version)
  [07:16:41.796]                       }
  [07:16:41.796]                       base::stop(msg)
  [07:16:41.796]                     }
  [07:16:41.796]                   })
  [07:16:41.796]                 }
  [07:16:41.796]                 base::local({
  [07:16:41.796]                   for (pkg in "future") {
  [07:16:41.796]                     base::loadNamespace(pkg)
  [07:16:41.796]                     base::library(pkg, character.only = TRUE)
  [07:16:41.796]                   }
  [07:16:41.796]                 })
  [07:16:41.796]             }
  [07:16:41.796]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.796]         }
  [07:16:41.796]     }
  [07:16:41.796]     if (base::is.na(TRUE)) {
  [07:16:41.796]     }
  [07:16:41.796]     else {
  [07:16:41.796]         if (TRUE) {
  [07:16:41.796]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.796]                 open = "w")
  [07:16:41.796]         }
  [07:16:41.796]         else {
  [07:16:41.796]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.796]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.796]         }
  [07:16:41.796]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.796]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.796]             base::sink(type = "output", split = FALSE)
  [07:16:41.796]             base::close(...future.stdout)
  [07:16:41.796]         }, add = TRUE)
  [07:16:41.796]     }
  [07:16:41.796]     ...future.frame <- base::sys.nframe()
  [07:16:41.796]     ...future.conditions <- base::list()
  [07:16:41.796]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.796]     ...future.result <- base::tryCatch({
  [07:16:41.796]         base::withCallingHandlers({
  [07:16:41.796]             ...future.value <- base::withVisible(base::local({
  [07:16:41.796]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:16:41.796]                   ii, n), appendLF = FALSE)
  [07:16:41.796]                 fit <- mandelbrot(C)
  [07:16:41.796]                 delay(fit)
  [07:16:41.796]                 message(" done")
  [07:16:41.796]                 fit
  [07:16:41.796]             }))
  [07:16:41.796]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.796]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.796]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.796]                 version = "1.8")
  [07:16:41.796]         }, condition = base::local({
  [07:16:41.796]             c <- base::c
  [07:16:41.796]             inherits <- base::inherits
  [07:16:41.796]             invokeRestart <- base::invokeRestart
  [07:16:41.796]             length <- base::length
  [07:16:41.796]             list <- base::list
  [07:16:41.796]             seq.int <- base::seq.int
  [07:16:41.796]             signalCondition <- base::signalCondition
  [07:16:41.796]             sys.calls <- base::sys.calls
  [07:16:41.796]             Sys.time <- base::Sys.time
  [07:16:41.796]             `[[` <- base::`[[`
  [07:16:41.796]             `+` <- base::`+`
  [07:16:41.796]             `<<-` <- base::`<<-`
  [07:16:41.796]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.796]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.796]                   3L)]
  [07:16:41.796]             }
  [07:16:41.796]             function(cond) {
  [07:16:41.796]                 if (inherits(cond, "error")) {
  [07:16:41.796]                   sessionInformation <- function() {
  [07:16:41.796]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.796]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.796]                       search = base::search(), system = base::Sys.info())
  [07:16:41.796]                   }
  [07:16:41.796]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.796]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.796]                     cond$call), session = sessionInformation(), 
  [07:16:41.796]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.796]                   signalCondition(cond)
  [07:16:41.796]                 }
  [07:16:41.796]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:16:41.796]                 ))) {
  [07:16:41.796]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.796]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.796]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.796]                   if (!signal) {
  [07:16:41.796]                     muffleCondition <- function (cond) 
  [07:16:41.796]                     {
  [07:16:41.796]                       inherits <- base::inherits
  [07:16:41.796]                       invokeRestart <- base::invokeRestart
  [07:16:41.796]                       muffled <- FALSE
  [07:16:41.796]                       if (inherits(cond, "message")) {
  [07:16:41.796]                         invokeRestart("muffleMessage")
  [07:16:41.796]                         muffled <- TRUE
  [07:16:41.796]                       }
  [07:16:41.796]                       else if (inherits(cond, "warning")) {
  [07:16:41.796]                         invokeRestart("muffleWarning")
  [07:16:41.796]                         muffled <- TRUE
  [07:16:41.796]                       }
  [07:16:41.796]                       else if (inherits(cond, "condition")) {
  [07:16:41.796]                         computeRestarts <- base::computeRestarts
  [07:16:41.796]                         grepl <- base::grepl
  [07:16:41.796]                         is.null <- base::is.null
  [07:16:41.796]                         restarts <- computeRestarts(cond)
  [07:16:41.796]                         for (restart in restarts) {
  [07:16:41.796]                           name <- restart$name
  [07:16:41.796]                           if (is.null(name)) 
  [07:16:41.796]                             next
  [07:16:41.796]                           if (!grepl("^muffle", name)) 
  [07:16:41.796]                             next
  [07:16:41.796]                           invokeRestart(restart)
  [07:16:41.796]                           muffled <- TRUE
  [07:16:41.796]                           break
  [07:16:41.796]                         }
  [07:16:41.796]                       }
  [07:16:41.796]                       invisible(muffled)
  [07:16:41.796]                     }
  [07:16:41.796]                     muffleCondition(cond)
  [07:16:41.796]                   }
  [07:16:41.796]                 }
  [07:16:41.796]             }
  [07:16:41.796]         }))
  [07:16:41.796]     }, error = function(ex) {
  [07:16:41.796]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.796]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.796]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.796]     }, finally = {
  [07:16:41.796]         {
  [07:16:41.796]             NULL
  [07:16:41.796]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.796]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.796]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.796]                 label = NULL, ...) 
  [07:16:41.796]             {
  [07:16:41.796]                 if (substitute) 
  [07:16:41.796]                   expr <- substitute(expr)
  [07:16:41.796]                 local <- as.logical(local)
  [07:16:41.796]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.796]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.796]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.796]                   label = label, ...)
  [07:16:41.796]                 if (!future$lazy) 
  [07:16:41.796]                   future <- run(future)
  [07:16:41.796]                 invisible(future)
  [07:16:41.796]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.796]         }
  [07:16:41.796]         base::options(...future.oldOptions)
  [07:16:41.796]     })
  [07:16:41.796]     Sys.time
  [07:16:41.796]     if (base::is.na(TRUE)) {
  [07:16:41.796]     }
  [07:16:41.796]     else {
  [07:16:41.796]         base::sink(type = "output", split = FALSE)
  [07:16:41.796]         if (TRUE) {
  [07:16:41.796]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.796]         }
  [07:16:41.796]         else {
  [07:16:41.796]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.796]         }
  [07:16:41.796]         base::close(...future.stdout)
  [07:16:41.796]         ...future.stdout <- NULL
  [07:16:41.796]     }
  [07:16:41.796]     ...future.result$conditions <- ...future.conditions
  [07:16:41.796]     ...future.result
  [07:16:41.796] }
  [07:16:41.800] plan(): Setting new future strategy stack:
  [07:16:41.801] List of future strategies:
  [07:16:41.801] 1. sequential:
  [07:16:41.801]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.801]    - tweaked: FALSE
  [07:16:41.801]    - call: NULL
  [07:16:41.801] plan(): nbrOfWorkers() = 1
  [07:16:41.804] plan(): Setting new future strategy stack:
  [07:16:41.804] List of future strategies:
  [07:16:41.804] 1. sequential:
  [07:16:41.804]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.804]    - tweaked: FALSE
  [07:16:41.804]    - call: plan(strategy)
  [07:16:41.805] plan(): nbrOfWorkers() = 1
  [07:16:41.805] SequentialFuture started (and completed)
  [07:16:41.805] signalConditions() ...
  [07:16:41.806]  - include = 'immediateCondition'
  [07:16:41.806]  - exclude = 
  [07:16:41.806]  - resignal = FALSE
  [07:16:41.806]  - Number of conditions: 2
  [07:16:41.807] signalConditions() ... done
  Plotting tile #1 of 4 ...
  [07:16:41.807] signalConditions() ...
  [07:16:41.807]  - include = 'immediateCondition'
  [07:16:41.808]  - exclude = 
  [07:16:41.808]  - resignal = FALSE
  [07:16:41.808]  - Number of conditions: 2
  [07:16:41.808] signalConditions() ... done
  [07:16:41.809] Future state: 'finished'
  [07:16:41.809] signalConditions() ...
  [07:16:41.809]  - include = 'condition'
  [07:16:41.809]  - exclude = 'immediateCondition'
  [07:16:41.809]  - resignal = TRUE
  [07:16:41.810]  - Number of conditions: 2
  [07:16:41.810]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #1 of 4 ...[07:16:41.810]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:16:41.810] signalConditions() ... done
  [07:16:41.814] Packages needed by the future expression (n = 1): 'future'
  [07:16:41.814] Packages needed by future strategies (n = 0): <none>
  [07:16:41.818] {
  [07:16:41.818]     {
  [07:16:41.818]         ...future.startTime <- base::Sys.time()
  [07:16:41.818]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.818]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.818]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.818]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.818]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.818]         {
  [07:16:41.818]             {
  [07:16:41.818]                 {
  [07:16:41.818]                   base::local({
  [07:16:41.818]                     has_future <- base::requireNamespace("future", 
  [07:16:41.818]                       quietly = TRUE)
  [07:16:41.818]                     version <- if (has_future) 
  [07:16:41.818]                       utils::packageVersion("future")
  [07:16:41.818]                     else NULL
  [07:16:41.818]                     if (!has_future || version < "1.8.0") {
  [07:16:41.818]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.818]                         "", base::R.version$version.string), 
  [07:16:41.818]                         platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.818]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.818]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.818]                           "release", "version")], collapse = " "), 
  [07:16:41.818]                         hostname = base::Sys.info()[["nodename"]])
  [07:16:41.818]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.818]                         info)
  [07:16:41.818]                       info <- base::paste(info, collapse = "; ")
  [07:16:41.818]                       if (!has_future) {
  [07:16:41.818]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.818]                           info)
  [07:16:41.818]                       }
  [07:16:41.818]                       else {
  [07:16:41.818]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.818]                           info, version)
  [07:16:41.818]                       }
  [07:16:41.818]                       base::stop(msg)
  [07:16:41.818]                     }
  [07:16:41.818]                   })
  [07:16:41.818]                 }
  [07:16:41.818]                 base::local({
  [07:16:41.818]                   for (pkg in "future") {
  [07:16:41.818]                     base::loadNamespace(pkg)
  [07:16:41.818]                     base::library(pkg, character.only = TRUE)
  [07:16:41.818]                   }
  [07:16:41.818]                 })
  [07:16:41.818]             }
  [07:16:41.818]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.818]         }
  [07:16:41.818]     }
  [07:16:41.818]     if (base::is.na(TRUE)) {
  [07:16:41.818]     }
  [07:16:41.818]     else {
  [07:16:41.818]         if (TRUE) {
  [07:16:41.818]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.818]                 open = "w")
  [07:16:41.818]         }
  [07:16:41.818]         else {
  [07:16:41.818]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.818]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.818]         }
  [07:16:41.818]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.818]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.818]             base::sink(type = "output", split = FALSE)
  [07:16:41.818]             base::close(...future.stdout)
  [07:16:41.818]         }, add = TRUE)
  [07:16:41.818]     }
  [07:16:41.818]     ...future.frame <- base::sys.nframe()
  [07:16:41.818]     ...future.conditions <- base::list()
  [07:16:41.818]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.818]     ...future.result <- base::tryCatch({
  [07:16:41.818]         base::withCallingHandlers({
  [07:16:41.818]             ...future.value <- base::withVisible(base::local({
  [07:16:41.818]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:16:41.818]                   ii, n), appendLF = FALSE)
  [07:16:41.818]                 fit <- mandelbrot(C)
  [07:16:41.818]                 delay(fit)
  [07:16:41.818]                 message(" done")
  [07:16:41.818]                 fit
  [07:16:41.818]             }))
  [07:16:41.818]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.818]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.818]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.818]                 version = "1.8")
  [07:16:41.818]         }, condition = base::local({
  [07:16:41.818]             c <- base::c
  [07:16:41.818]             inherits <- base::inherits
  [07:16:41.818]             invokeRestart <- base::invokeRestart
  [07:16:41.818]             length <- base::length
  [07:16:41.818]             list <- base::list
  [07:16:41.818]             seq.int <- base::seq.int
  [07:16:41.818]             signalCondition <- base::signalCondition
  [07:16:41.818]             sys.calls <- base::sys.calls
  [07:16:41.818]             Sys.time <- base::Sys.time
  [07:16:41.818]             `[[` <- base::`[[`
  [07:16:41.818]             `+` <- base::`+`
  [07:16:41.818]             `<<-` <- base::`<<-`
  [07:16:41.818]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.818]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.818]                   3L)]
  [07:16:41.818]             }
  [07:16:41.818]             function(cond) {
  [07:16:41.818]                 if (inherits(cond, "error")) {
  [07:16:41.818]                   sessionInformation <- function() {
  [07:16:41.818]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.818]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.818]                       search = base::search(), system = base::Sys.info())
  [07:16:41.818]                   }
  [07:16:41.818]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.818]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.818]                     cond$call), session = sessionInformation(), 
  [07:16:41.818]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.818]                   signalCondition(cond)
  [07:16:41.818]                 }
  [07:16:41.818]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:16:41.818]                 ))) {
  [07:16:41.818]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.818]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.818]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.818]                   if (!signal) {
  [07:16:41.818]                     muffleCondition <- function (cond) 
  [07:16:41.818]                     {
  [07:16:41.818]                       inherits <- base::inherits
  [07:16:41.818]                       invokeRestart <- base::invokeRestart
  [07:16:41.818]                       muffled <- FALSE
  [07:16:41.818]                       if (inherits(cond, "message")) {
  [07:16:41.818]                         invokeRestart("muffleMessage")
  [07:16:41.818]                         muffled <- TRUE
  [07:16:41.818]                       }
  [07:16:41.818]                       else if (inherits(cond, "warning")) {
  [07:16:41.818]                         invokeRestart("muffleWarning")
  [07:16:41.818]                         muffled <- TRUE
  [07:16:41.818]                       }
  [07:16:41.818]                       else if (inherits(cond, "condition")) {
  [07:16:41.818]                         computeRestarts <- base::computeRestarts
  [07:16:41.818]                         grepl <- base::grepl
  [07:16:41.818]                         is.null <- base::is.null
  [07:16:41.818]                         restarts <- computeRestarts(cond)
  [07:16:41.818]                         for (restart in restarts) {
  [07:16:41.818]                           name <- restart$name
  [07:16:41.818]                           if (is.null(name)) 
  [07:16:41.818]                             next
  [07:16:41.818]                           if (!grepl("^muffle", name)) 
  [07:16:41.818]                             next
  [07:16:41.818]                           invokeRestart(restart)
  [07:16:41.818]                           muffled <- TRUE
  [07:16:41.818]                           break
  [07:16:41.818]                         }
  [07:16:41.818]                       }
  [07:16:41.818]                       invisible(muffled)
  [07:16:41.818]                     }
  [07:16:41.818]                     muffleCondition(cond)
  [07:16:41.818]                   }
  [07:16:41.818]                 }
  [07:16:41.818]             }
  [07:16:41.818]         }))
  [07:16:41.818]     }, error = function(ex) {
  [07:16:41.818]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.818]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.818]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.818]     }, finally = {
  [07:16:41.818]         {
  [07:16:41.818]             NULL
  [07:16:41.818]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.818]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.818]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.818]                 label = NULL, ...) 
  [07:16:41.818]             {
  [07:16:41.818]                 if (substitute) 
  [07:16:41.818]                   expr <- substitute(expr)
  [07:16:41.818]                 local <- as.logical(local)
  [07:16:41.818]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.818]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.818]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.818]                   label = label, ...)
  [07:16:41.818]                 if (!future$lazy) 
  [07:16:41.818]                   future <- run(future)
  [07:16:41.818]                 invisible(future)
  [07:16:41.818]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.818]         }
  [07:16:41.818]         base::options(...future.oldOptions)
  [07:16:41.818]     })
  [07:16:41.818]     Sys.time
  [07:16:41.818]     if (base::is.na(TRUE)) {
  [07:16:41.818]     }
  [07:16:41.818]     else {
  [07:16:41.818]         base::sink(type = "output", split = FALSE)
  [07:16:41.818]         if (TRUE) {
  [07:16:41.818]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.818]         }
  [07:16:41.818]         else {
  [07:16:41.818]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.818]         }
  [07:16:41.818]         base::close(...future.stdout)
  [07:16:41.818]         ...future.stdout <- NULL
  [07:16:41.818]     }
  [07:16:41.818]     ...future.result$conditions <- ...future.conditions
  [07:16:41.818]     ...future.result
  [07:16:41.818] }
  [07:16:41.821] plan(): Setting new future strategy stack:
  [07:16:41.822] List of future strategies:
  [07:16:41.822] 1. sequential:
  [07:16:41.822]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.822]    - tweaked: FALSE
  [07:16:41.822]    - call: NULL
  [07:16:41.822] plan(): nbrOfWorkers() = 1
  [07:16:41.826] plan(): Setting new future strategy stack:
  [07:16:41.827] List of future strategies:
  [07:16:41.827] 1. sequential:
  [07:16:41.827]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.827]    - tweaked: FALSE
  [07:16:41.827]    - call: plan(strategy)
  [07:16:41.827] plan(): nbrOfWorkers() = 1
  [07:16:41.828] SequentialFuture started (and completed)
  [07:16:41.828] signalConditions() ...
  [07:16:41.828]  - include = 'immediateCondition'
  [07:16:41.829]  - exclude = 
  [07:16:41.829]  - resignal = FALSE
  [07:16:41.829]  - Number of conditions: 2
  [07:16:41.829] signalConditions() ... done
  Plotting tile #2 of 4 ...
  [07:16:41.830] signalConditions() ...
  [07:16:41.830]  - include = 'immediateCondition'
  [07:16:41.830]  - exclude = 
  [07:16:41.830]  - resignal = FALSE
  [07:16:41.831]  - Number of conditions: 2
  [07:16:41.831] signalConditions() ... done
  [07:16:41.831] Future state: 'finished'
  [07:16:41.831] signalConditions() ...
  [07:16:41.832]  - include = 'condition'
  [07:16:41.832]  - exclude = 'immediateCondition'
  [07:16:41.832]  - resignal = TRUE
  [07:16:41.832]  - Number of conditions: 2
  [07:16:41.832]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #2 of 4 ...[07:16:41.833]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:16:41.833] signalConditions() ... done
  [07:16:41.835] Packages needed by the future expression (n = 1): 'future'
  [07:16:41.835] Packages needed by future strategies (n = 0): <none>
  [07:16:41.841] {
  [07:16:41.841]     {
  [07:16:41.841]         ...future.startTime <- base::Sys.time()
  [07:16:41.841]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.841]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.841]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.841]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.841]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.841]         {
  [07:16:41.841]             {
  [07:16:41.841]                 {
  [07:16:41.841]                   base::local({
  [07:16:41.841]                     has_future <- base::requireNamespace("future", 
  [07:16:41.841]                       quietly = TRUE)
  [07:16:41.841]                     version <- if (has_future) 
  [07:16:41.841]                       utils::packageVersion("future")
  [07:16:41.841]                     else NULL
  [07:16:41.841]                     if (!has_future || version < "1.8.0") {
  [07:16:41.841]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.841]                         "", base::R.version$version.string), 
  [07:16:41.841]                         platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.841]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.841]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.841]                           "release", "version")], collapse = " "), 
  [07:16:41.841]                         hostname = base::Sys.info()[["nodename"]])
  [07:16:41.841]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.841]                         info)
  [07:16:41.841]                       info <- base::paste(info, collapse = "; ")
  [07:16:41.841]                       if (!has_future) {
  [07:16:41.841]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.841]                           info)
  [07:16:41.841]                       }
  [07:16:41.841]                       else {
  [07:16:41.841]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.841]                           info, version)
  [07:16:41.841]                       }
  [07:16:41.841]                       base::stop(msg)
  [07:16:41.841]                     }
  [07:16:41.841]                   })
  [07:16:41.841]                 }
  [07:16:41.841]                 base::local({
  [07:16:41.841]                   for (pkg in "future") {
  [07:16:41.841]                     base::loadNamespace(pkg)
  [07:16:41.841]                     base::library(pkg, character.only = TRUE)
  [07:16:41.841]                   }
  [07:16:41.841]                 })
  [07:16:41.841]             }
  [07:16:41.841]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.841]         }
  [07:16:41.841]     }
  [07:16:41.841]     if (base::is.na(TRUE)) {
  [07:16:41.841]     }
  [07:16:41.841]     else {
  [07:16:41.841]         if (TRUE) {
  [07:16:41.841]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.841]                 open = "w")
  [07:16:41.841]         }
  [07:16:41.841]         else {
  [07:16:41.841]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.841]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.841]         }
  [07:16:41.841]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.841]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.841]             base::sink(type = "output", split = FALSE)
  [07:16:41.841]             base::close(...future.stdout)
  [07:16:41.841]         }, add = TRUE)
  [07:16:41.841]     }
  [07:16:41.841]     ...future.frame <- base::sys.nframe()
  [07:16:41.841]     ...future.conditions <- base::list()
  [07:16:41.841]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.841]     ...future.result <- base::tryCatch({
  [07:16:41.841]         base::withCallingHandlers({
  [07:16:41.841]             ...future.value <- base::withVisible(base::local({
  [07:16:41.841]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:16:41.841]                   ii, n), appendLF = FALSE)
  [07:16:41.841]                 fit <- mandelbrot(C)
  [07:16:41.841]                 delay(fit)
  [07:16:41.841]                 message(" done")
  [07:16:41.841]                 fit
  [07:16:41.841]             }))
  [07:16:41.841]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.841]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.841]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.841]                 version = "1.8")
  [07:16:41.841]         }, condition = base::local({
  [07:16:41.841]             c <- base::c
  [07:16:41.841]             inherits <- base::inherits
  [07:16:41.841]             invokeRestart <- base::invokeRestart
  [07:16:41.841]             length <- base::length
  [07:16:41.841]             list <- base::list
  [07:16:41.841]             seq.int <- base::seq.int
  [07:16:41.841]             signalCondition <- base::signalCondition
  [07:16:41.841]             sys.calls <- base::sys.calls
  [07:16:41.841]             Sys.time <- base::Sys.time
  [07:16:41.841]             `[[` <- base::`[[`
  [07:16:41.841]             `+` <- base::`+`
  [07:16:41.841]             `<<-` <- base::`<<-`
  [07:16:41.841]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.841]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.841]                   3L)]
  [07:16:41.841]             }
  [07:16:41.841]             function(cond) {
  [07:16:41.841]                 if (inherits(cond, "error")) {
  [07:16:41.841]                   sessionInformation <- function() {
  [07:16:41.841]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.841]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.841]                       search = base::search(), system = base::Sys.info())
  [07:16:41.841]                   }
  [07:16:41.841]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.841]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.841]                     cond$call), session = sessionInformation(), 
  [07:16:41.841]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.841]                   signalCondition(cond)
  [07:16:41.841]                 }
  [07:16:41.841]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:16:41.841]                 ))) {
  [07:16:41.841]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.841]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.841]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.841]                   if (!signal) {
  [07:16:41.841]                     muffleCondition <- function (cond) 
  [07:16:41.841]                     {
  [07:16:41.841]                       inherits <- base::inherits
  [07:16:41.841]                       invokeRestart <- base::invokeRestart
  [07:16:41.841]                       muffled <- FALSE
  [07:16:41.841]                       if (inherits(cond, "message")) {
  [07:16:41.841]                         invokeRestart("muffleMessage")
  [07:16:41.841]                         muffled <- TRUE
  [07:16:41.841]                       }
  [07:16:41.841]                       else if (inherits(cond, "warning")) {
  [07:16:41.841]                         invokeRestart("muffleWarning")
  [07:16:41.841]                         muffled <- TRUE
  [07:16:41.841]                       }
  [07:16:41.841]                       else if (inherits(cond, "condition")) {
  [07:16:41.841]                         computeRestarts <- base::computeRestarts
  [07:16:41.841]                         grepl <- base::grepl
  [07:16:41.841]                         is.null <- base::is.null
  [07:16:41.841]                         restarts <- computeRestarts(cond)
  [07:16:41.841]                         for (restart in restarts) {
  [07:16:41.841]                           name <- restart$name
  [07:16:41.841]                           if (is.null(name)) 
  [07:16:41.841]                             next
  [07:16:41.841]                           if (!grepl("^muffle", name)) 
  [07:16:41.841]                             next
  [07:16:41.841]                           invokeRestart(restart)
  [07:16:41.841]                           muffled <- TRUE
  [07:16:41.841]                           break
  [07:16:41.841]                         }
  [07:16:41.841]                       }
  [07:16:41.841]                       invisible(muffled)
  [07:16:41.841]                     }
  [07:16:41.841]                     muffleCondition(cond)
  [07:16:41.841]                   }
  [07:16:41.841]                 }
  [07:16:41.841]             }
  [07:16:41.841]         }))
  [07:16:41.841]     }, error = function(ex) {
  [07:16:41.841]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.841]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.841]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.841]     }, finally = {
  [07:16:41.841]         {
  [07:16:41.841]             NULL
  [07:16:41.841]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.841]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.841]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.841]                 label = NULL, ...) 
  [07:16:41.841]             {
  [07:16:41.841]                 if (substitute) 
  [07:16:41.841]                   expr <- substitute(expr)
  [07:16:41.841]                 local <- as.logical(local)
  [07:16:41.841]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.841]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.841]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.841]                   label = label, ...)
  [07:16:41.841]                 if (!future$lazy) 
  [07:16:41.841]                   future <- run(future)
  [07:16:41.841]                 invisible(future)
  [07:16:41.841]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.841]         }
  [07:16:41.841]         base::options(...future.oldOptions)
  [07:16:41.841]     })
  [07:16:41.841]     Sys.time
  [07:16:41.841]     if (base::is.na(TRUE)) {
  [07:16:41.841]     }
  [07:16:41.841]     else {
  [07:16:41.841]         base::sink(type = "output", split = FALSE)
  [07:16:41.841]         if (TRUE) {
  [07:16:41.841]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.841]         }
  [07:16:41.841]         else {
  [07:16:41.841]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.841]         }
  [07:16:41.841]         base::close(...future.stdout)
  [07:16:41.841]         ...future.stdout <- NULL
  [07:16:41.841]     }
  [07:16:41.841]     ...future.result$conditions <- ...future.conditions
  [07:16:41.841]     ...future.result
  [07:16:41.841] }
  [07:16:41.845] plan(): Setting new future strategy stack:
  [07:16:41.846] List of future strategies:
  [07:16:41.846] 1. sequential:
  [07:16:41.846]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.846]    - tweaked: FALSE
  [07:16:41.846]    - call: NULL
  [07:16:41.846] plan(): nbrOfWorkers() = 1
  [07:16:41.848] plan(): Setting new future strategy stack:
  [07:16:41.849] List of future strategies:
  [07:16:41.849] 1. sequential:
  [07:16:41.849]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.849]    - tweaked: FALSE
  [07:16:41.849]    - call: plan(strategy)
  [07:16:41.849] plan(): nbrOfWorkers() = 1
  [07:16:41.850] SequentialFuture started (and completed)
  [07:16:41.850] signalConditions() ...
  [07:16:41.850]  - include = 'immediateCondition'
  [07:16:41.850]  - exclude = 
  [07:16:41.851]  - resignal = FALSE
  [07:16:41.851]  - Number of conditions: 2
  [07:16:41.851] signalConditions() ... done
  Plotting tile #3 of 4 ...
  [07:16:41.852] signalConditions() ...
  [07:16:41.852]  - include = 'immediateCondition'
  [07:16:41.852]  - exclude = 
  [07:16:41.852]  - resignal = FALSE
  [07:16:41.853]  - Number of conditions: 2
  [07:16:41.853] signalConditions() ... done
  [07:16:41.853] Future state: 'finished'
  [07:16:41.853] signalConditions() ...
  [07:16:41.854]  - include = 'condition'
  [07:16:41.854]  - exclude = 'immediateCondition'
  [07:16:41.854]  - resignal = TRUE
  [07:16:41.854]  - Number of conditions: 2
  [07:16:41.855]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #3 of 4 ...[07:16:41.855]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:16:41.855] signalConditions() ... done
  [07:16:41.857] Packages needed by the future expression (n = 1): 'future'
  [07:16:41.857] Packages needed by future strategies (n = 0): <none>
  [07:16:41.861] {
  [07:16:41.861]     {
  [07:16:41.861]         ...future.startTime <- base::Sys.time()
  [07:16:41.861]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.861]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.861]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.861]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.861]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.861]         {
  [07:16:41.861]             {
  [07:16:41.861]                 {
  [07:16:41.861]                   base::local({
  [07:16:41.861]                     has_future <- base::requireNamespace("future", 
  [07:16:41.861]                       quietly = TRUE)
  [07:16:41.861]                     version <- if (has_future) 
  [07:16:41.861]                       utils::packageVersion("future")
  [07:16:41.861]                     else NULL
  [07:16:41.861]                     if (!has_future || version < "1.8.0") {
  [07:16:41.861]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.861]                         "", base::R.version$version.string), 
  [07:16:41.861]                         platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.861]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.861]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.861]                           "release", "version")], collapse = " "), 
  [07:16:41.861]                         hostname = base::Sys.info()[["nodename"]])
  [07:16:41.861]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.861]                         info)
  [07:16:41.861]                       info <- base::paste(info, collapse = "; ")
  [07:16:41.861]                       if (!has_future) {
  [07:16:41.861]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.861]                           info)
  [07:16:41.861]                       }
  [07:16:41.861]                       else {
  [07:16:41.861]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.861]                           info, version)
  [07:16:41.861]                       }
  [07:16:41.861]                       base::stop(msg)
  [07:16:41.861]                     }
  [07:16:41.861]                   })
  [07:16:41.861]                 }
  [07:16:41.861]                 base::local({
  [07:16:41.861]                   for (pkg in "future") {
  [07:16:41.861]                     base::loadNamespace(pkg)
  [07:16:41.861]                     base::library(pkg, character.only = TRUE)
  [07:16:41.861]                   }
  [07:16:41.861]                 })
  [07:16:41.861]             }
  [07:16:41.861]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.861]         }
  [07:16:41.861]     }
  [07:16:41.861]     if (base::is.na(TRUE)) {
  [07:16:41.861]     }
  [07:16:41.861]     else {
  [07:16:41.861]         if (TRUE) {
  [07:16:41.861]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.861]                 open = "w")
  [07:16:41.861]         }
  [07:16:41.861]         else {
  [07:16:41.861]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.861]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.861]         }
  [07:16:41.861]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.861]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.861]             base::sink(type = "output", split = FALSE)
  [07:16:41.861]             base::close(...future.stdout)
  [07:16:41.861]         }, add = TRUE)
  [07:16:41.861]     }
  [07:16:41.861]     ...future.frame <- base::sys.nframe()
  [07:16:41.861]     ...future.conditions <- base::list()
  [07:16:41.861]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.861]     ...future.result <- base::tryCatch({
  [07:16:41.861]         base::withCallingHandlers({
  [07:16:41.861]             ...future.value <- base::withVisible(base::local({
  [07:16:41.861]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:16:41.861]                   ii, n), appendLF = FALSE)
  [07:16:41.861]                 fit <- mandelbrot(C)
  [07:16:41.861]                 delay(fit)
  [07:16:41.861]                 message(" done")
  [07:16:41.861]                 fit
  [07:16:41.861]             }))
  [07:16:41.861]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.861]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.861]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.861]                 version = "1.8")
  [07:16:41.861]         }, condition = base::local({
  [07:16:41.861]             c <- base::c
  [07:16:41.861]             inherits <- base::inherits
  [07:16:41.861]             invokeRestart <- base::invokeRestart
  [07:16:41.861]             length <- base::length
  [07:16:41.861]             list <- base::list
  [07:16:41.861]             seq.int <- base::seq.int
  [07:16:41.861]             signalCondition <- base::signalCondition
  [07:16:41.861]             sys.calls <- base::sys.calls
  [07:16:41.861]             Sys.time <- base::Sys.time
  [07:16:41.861]             `[[` <- base::`[[`
  [07:16:41.861]             `+` <- base::`+`
  [07:16:41.861]             `<<-` <- base::`<<-`
  [07:16:41.861]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.861]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.861]                   3L)]
  [07:16:41.861]             }
  [07:16:41.861]             function(cond) {
  [07:16:41.861]                 if (inherits(cond, "error")) {
  [07:16:41.861]                   sessionInformation <- function() {
  [07:16:41.861]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.861]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.861]                       search = base::search(), system = base::Sys.info())
  [07:16:41.861]                   }
  [07:16:41.861]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.861]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.861]                     cond$call), session = sessionInformation(), 
  [07:16:41.861]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.861]                   signalCondition(cond)
  [07:16:41.861]                 }
  [07:16:41.861]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:16:41.861]                 ))) {
  [07:16:41.861]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:16:41.861]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.861]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.861]                   if (!signal) {
  [07:16:41.861]                     muffleCondition <- function (cond) 
  [07:16:41.861]                     {
  [07:16:41.861]                       inherits <- base::inherits
  [07:16:41.861]                       invokeRestart <- base::invokeRestart
  [07:16:41.861]                       muffled <- FALSE
  [07:16:41.861]                       if (inherits(cond, "message")) {
  [07:16:41.861]                         invokeRestart("muffleMessage")
  [07:16:41.861]                         muffled <- TRUE
  [07:16:41.861]                       }
  [07:16:41.861]                       else if (inherits(cond, "warning")) {
  [07:16:41.861]                         invokeRestart("muffleWarning")
  [07:16:41.861]                         muffled <- TRUE
  [07:16:41.861]                       }
  [07:16:41.861]                       else if (inherits(cond, "condition")) {
  [07:16:41.861]                         computeRestarts <- base::computeRestarts
  [07:16:41.861]                         grepl <- base::grepl
  [07:16:41.861]                         is.null <- base::is.null
  [07:16:41.861]                         restarts <- computeRestarts(cond)
  [07:16:41.861]                         for (restart in restarts) {
  [07:16:41.861]                           name <- restart$name
  [07:16:41.861]                           if (is.null(name)) 
  [07:16:41.861]                             next
  [07:16:41.861]                           if (!grepl("^muffle", name)) 
  [07:16:41.861]                             next
  [07:16:41.861]                           invokeRestart(restart)
  [07:16:41.861]                           muffled <- TRUE
  [07:16:41.861]                           break
  [07:16:41.861]                         }
  [07:16:41.861]                       }
  [07:16:41.861]                       invisible(muffled)
  [07:16:41.861]                     }
  [07:16:41.861]                     muffleCondition(cond)
  [07:16:41.861]                   }
  [07:16:41.861]                 }
  [07:16:41.861]             }
  [07:16:41.861]         }))
  [07:16:41.861]     }, error = function(ex) {
  [07:16:41.861]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.861]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.861]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.861]     }, finally = {
  [07:16:41.861]         {
  [07:16:41.861]             NULL
  [07:16:41.861]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.861]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.861]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:16:41.861]                 label = NULL, ...) 
  [07:16:41.861]             {
  [07:16:41.861]                 if (substitute) 
  [07:16:41.861]                   expr <- substitute(expr)
  [07:16:41.861]                 local <- as.logical(local)
  [07:16:41.861]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:16:41.861]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.861]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:16:41.861]                   label = label, ...)
  [07:16:41.861]                 if (!future$lazy) 
  [07:16:41.861]                   future <- run(future)
  [07:16:41.861]                 invisible(future)
  [07:16:41.861]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.861]         }
  [07:16:41.861]         base::options(...future.oldOptions)
  [07:16:41.861]     })
  [07:16:41.861]     Sys.time
  [07:16:41.861]     if (base::is.na(TRUE)) {
  [07:16:41.861]     }
  [07:16:41.861]     else {
  [07:16:41.861]         base::sink(type = "output", split = FALSE)
  [07:16:41.861]         if (TRUE) {
  [07:16:41.861]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.861]         }
  [07:16:41.861]         else {
  [07:16:41.861]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.861]         }
  [07:16:41.861]         base::close(...future.stdout)
  [07:16:41.861]         ...future.stdout <- NULL
  [07:16:41.861]     }
  [07:16:41.861]     ...future.result$conditions <- ...future.conditions
  [07:16:41.861]     ...future.result
  [07:16:41.861] }
  [07:16:41.865] plan(): Setting new future strategy stack:
  [07:16:41.865] List of future strategies:
  [07:16:41.865] 1. sequential:
  [07:16:41.865]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.865]    - tweaked: FALSE
  [07:16:41.865]    - call: NULL
  [07:16:41.866] plan(): nbrOfWorkers() = 1
  [07:16:41.868] plan(): Setting new future strategy stack:
  [07:16:41.869] List of future strategies:
  [07:16:41.869] 1. sequential:
  [07:16:41.869]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.869]    - tweaked: FALSE
  [07:16:41.869]    - call: plan(strategy)
  [07:16:41.869] plan(): nbrOfWorkers() = 1
  [07:16:41.870] SequentialFuture started (and completed)
  [07:16:41.870] signalConditions() ...
  [07:16:41.870]  - include = 'immediateCondition'
  [07:16:41.870]  - exclude = 
  [07:16:41.871]  - resignal = FALSE
  [07:16:41.871]  - Number of conditions: 2
  [07:16:41.871] signalConditions() ... done
  Plotting tile #4 of 4 ...
  [07:16:41.872] signalConditions() ...
  [07:16:41.872]  - include = 'immediateCondition'
  [07:16:41.872]  - exclude = 
  [07:16:41.872]  - resignal = FALSE
  [07:16:41.873]  - Number of conditions: 2
  [07:16:41.873] signalConditions() ... done
  [07:16:41.873] Future state: 'finished'
  [07:16:41.873] signalConditions() ...
  [07:16:41.873]  - include = 'condition'
  [07:16:41.874]  - exclude = 'immediateCondition'
  [07:16:41.874]  - resignal = TRUE
  [07:16:41.874]  - Number of conditions: 2
  [07:16:41.874]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #4 of 4 ...[07:16:41.875]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:16:41.875] 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:16:41.887] plan(): Setting new future strategy stack:
  [07:16:41.887] List of future strategies:
  [07:16:41.887] 1. multicore:
  [07:16:41.887]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:16:41.887]    - tweaked: FALSE
  [07:16:41.887]    - call: plan(strategy)
  [07:16:41.888] 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:16:41.895] getGlobalsAndPackages() ...
  [07:16:41.895] Searching for globals...
  [07:16:41.900] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:16:41.900] Searching for globals ... DONE
  [07:16:41.900] Resolving globals: FALSE
  [07:16:41.901] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:16:41.901] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:16:41.902] - packages: [1] 'future'
  [07:16:41.902] getGlobalsAndPackages() ... DONE
   2[07:16:41.909] getGlobalsAndPackages() ...
  [07:16:41.909] Searching for globals...
  [07:16:41.913] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:16:41.913] Searching for globals ... DONE
  [07:16:41.913] Resolving globals: FALSE
  [07:16:41.914] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:16:41.915] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:16:41.915] - packages: [1] 'future'
  [07:16:41.915] getGlobalsAndPackages() ... DONE
   3[07:16:41.916] getGlobalsAndPackages() ...
  [07:16:41.916] Searching for globals...
  [07:16:41.920] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:16:41.920] Searching for globals ... DONE
  [07:16:41.920] Resolving globals: FALSE
  [07:16:41.921] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:16:41.922] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:16:41.922] - packages: [1] 'future'
  [07:16:41.922] getGlobalsAndPackages() ... DONE
   4[07:16:41.923] getGlobalsAndPackages() ...
  [07:16:41.923] Searching for globals...
  [07:16:41.930] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
  [07:16:41.930] Searching for globals ... DONE
  [07:16:41.930] Resolving globals: FALSE
  [07:16:41.931] The total size of the 4 globals is 14.24 KiB (14584 bytes)
  [07:16:41.932] - globals: [4] 'ii', 'n', 'C', 'delay'
  [07:16:41.932] - packages: [1] 'future'
  [07:16:41.932] getGlobalsAndPackages() ... DONE
  
  > message(".")
  .
  
  > ## Calculate and plot tiles
  > repeat {
  +   counts <- plot_what_is_done(counts)
  +   if (!any(sapply(counts, FUN = inherits, "Future"))) break
  + }
  [07:16:41.949] Packages needed by the future expression (n = 0): <none>
  [07:16:41.949] Packages needed by future strategies (n = 0): <none>
  [07:16:41.953] {
  [07:16:41.953]     {
  [07:16:41.953]         ...future.startTime <- base::Sys.time()
  [07:16:41.953]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.953]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.953]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.953]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.953]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.953]         {
  [07:16:41.953]             {
  [07:16:41.953]                 {
  [07:16:41.953]                   base::local({
  [07:16:41.953]                     has_future <- base::requireNamespace("future", 
  [07:16:41.953]                       quietly = TRUE)
  [07:16:41.953]                     version <- if (has_future) 
  [07:16:41.953]                       utils::packageVersion("future")
  [07:16:41.953]                     else NULL
  [07:16:41.953]                     if (!has_future || version < "1.8.0") {
  [07:16:41.953]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.953]                         "", base::R.version$version.string), 
  [07:16:41.953]                         platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.953]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.953]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.953]                           "release", "version")], collapse = " "), 
  [07:16:41.953]                         hostname = base::Sys.info()[["nodename"]])
  [07:16:41.953]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.953]                         info)
  [07:16:41.953]                       info <- base::paste(info, collapse = "; ")
  [07:16:41.953]                       if (!has_future) {
  [07:16:41.953]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.953]                           info)
  [07:16:41.953]                       }
  [07:16:41.953]                       else {
  [07:16:41.953]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.953]                           info, version)
  [07:16:41.953]                       }
  [07:16:41.953]                       base::stop(msg)
  [07:16:41.953]                     }
  [07:16:41.953]                   })
  [07:16:41.953]                 }
  [07:16:41.953]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:16:41.953]                 base::options(mc.cores = 1L)
  [07:16:41.953]             }
  [07:16:41.953]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.953]         }
  [07:16:41.953]     }
  [07:16:41.953]     if (base::is.na(TRUE)) {
  [07:16:41.953]     }
  [07:16:41.953]     else {
  [07:16:41.953]         if (TRUE) {
  [07:16:41.953]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.953]                 open = "w")
  [07:16:41.953]         }
  [07:16:41.953]         else {
  [07:16:41.953]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.953]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.953]         }
  [07:16:41.953]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.953]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.953]             base::sink(type = "output", split = FALSE)
  [07:16:41.953]             base::close(...future.stdout)
  [07:16:41.953]         }, add = TRUE)
  [07:16:41.953]     }
  [07:16:41.953]     ...future.frame <- base::sys.nframe()
  [07:16:41.953]     ...future.conditions <- base::list()
  [07:16:41.953]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.953]     ...future.result <- base::tryCatch({
  [07:16:41.953]         base::withCallingHandlers({
  [07:16:41.953]             ...future.value <- base::withVisible(base::local({
  [07:16:41.953]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:16:41.953]                   ii, n), appendLF = FALSE)
  [07:16:41.953]                 fit <- mandelbrot(C)
  [07:16:41.953]                 delay(fit)
  [07:16:41.953]                 message(" done")
  [07:16:41.953]                 fit
  [07:16:41.953]             }))
  [07:16:41.953]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.953]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.953]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.953]                 version = "1.8")
  [07:16:41.953]         }, condition = base::local({
  [07:16:41.953]             c <- base::c
  [07:16:41.953]             inherits <- base::inherits
  [07:16:41.953]             invokeRestart <- base::invokeRestart
  [07:16:41.953]             length <- base::length
  [07:16:41.953]             list <- base::list
  [07:16:41.953]             seq.int <- base::seq.int
  [07:16:41.953]             signalCondition <- base::signalCondition
  [07:16:41.953]             sys.calls <- base::sys.calls
  [07:16:41.953]             Sys.time <- base::Sys.time
  [07:16:41.953]             `[[` <- base::`[[`
  [07:16:41.953]             `+` <- base::`+`
  [07:16:41.953]             `<<-` <- base::`<<-`
  [07:16:41.953]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.953]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.953]                   3L)]
  [07:16:41.953]             }
  [07:16:41.953]             function(cond) {
  [07:16:41.953]                 if (inherits(cond, "error")) {
  [07:16:41.953]                   sessionInformation <- function() {
  [07:16:41.953]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.953]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.953]                       search = base::search(), system = base::Sys.info())
  [07:16:41.953]                   }
  [07:16:41.953]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.953]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.953]                     cond$call), session = sessionInformation(), 
  [07:16:41.953]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.953]                   signalCondition(cond)
  [07:16:41.953]                 }
  [07:16:41.953]                 else if (inherits(cond, "condition")) {
  [07:16:41.953]                   signal <- FALSE && inherits(cond, character(0))
  [07:16:41.953]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.953]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.953]                   if (!signal) {
  [07:16:41.953]                     muffleCondition <- function (cond) 
  [07:16:41.953]                     {
  [07:16:41.953]                       inherits <- base::inherits
  [07:16:41.953]                       invokeRestart <- base::invokeRestart
  [07:16:41.953]                       muffled <- FALSE
  [07:16:41.953]                       if (inherits(cond, "message")) {
  [07:16:41.953]                         invokeRestart("muffleMessage")
  [07:16:41.953]                         muffled <- TRUE
  [07:16:41.953]                       }
  [07:16:41.953]                       else if (inherits(cond, "warning")) {
  [07:16:41.953]                         invokeRestart("muffleWarning")
  [07:16:41.953]                         muffled <- TRUE
  [07:16:41.953]                       }
  [07:16:41.953]                       else if (inherits(cond, "condition")) {
  [07:16:41.953]                         computeRestarts <- base::computeRestarts
  [07:16:41.953]                         grepl <- base::grepl
  [07:16:41.953]                         is.null <- base::is.null
  [07:16:41.953]                         restarts <- computeRestarts(cond)
  [07:16:41.953]                         for (restart in restarts) {
  [07:16:41.953]                           name <- restart$name
  [07:16:41.953]                           if (is.null(name)) 
  [07:16:41.953]                             next
  [07:16:41.953]                           if (!grepl("^muffle", name)) 
  [07:16:41.953]                             next
  [07:16:41.953]                           invokeRestart(restart)
  [07:16:41.953]                           muffled <- TRUE
  [07:16:41.953]                           break
  [07:16:41.953]                         }
  [07:16:41.953]                       }
  [07:16:41.953]                       invisible(muffled)
  [07:16:41.953]                     }
  [07:16:41.953]                     muffleCondition(cond)
  [07:16:41.953]                   }
  [07:16:41.953]                 }
  [07:16:41.953]             }
  [07:16:41.953]         }))
  [07:16:41.953]     }, error = function(ex) {
  [07:16:41.953]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.953]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.953]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.953]     }, finally = {
  [07:16:41.953]         {
  [07:16:41.953]             {
  [07:16:41.953]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:16:41.953]             }
  [07:16:41.953]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.953]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.953]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:16:41.953]                 earlySignal = FALSE, label = NULL, ...) 
  [07:16:41.953]             {
  [07:16:41.953]                 if (substitute) 
  [07:16:41.953]                   expr <- substitute(expr)
  [07:16:41.953]                 if (is.function(workers)) 
  [07:16:41.953]                   workers <- workers()
  [07:16:41.953]                 workers <- as.integer(workers)
  [07:16:41.953]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:16:41.953]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:16:41.953]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:16:41.953]                     lazy = lazy, seed = seed, globals = globals, 
  [07:16:41.953]                     local = TRUE, label = label, ...))
  [07:16:41.953]                 }
  [07:16:41.953]                 oopts <- options(mc.cores = workers)
  [07:16:41.953]                 on.exit(options(oopts))
  [07:16:41.953]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:16:41.953]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.953]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:16:41.953]                   label = label, ...)
  [07:16:41.953]                 if (!future$lazy) 
  [07:16:41.953]                   future <- run(future)
  [07:16:41.953]                 invisible(future)
  [07:16:41.953]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.953]         }
  [07:16:41.953]         base::options(...future.oldOptions)
  [07:16:41.953]     })
  [07:16:41.953]     Sys.time
  [07:16:41.953]     if (base::is.na(TRUE)) {
  [07:16:41.953]     }
  [07:16:41.953]     else {
  [07:16:41.953]         base::sink(type = "output", split = FALSE)
  [07:16:41.953]         if (TRUE) {
  [07:16:41.953]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.953]         }
  [07:16:41.953]         else {
  [07:16:41.953]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.953]         }
  [07:16:41.953]         base::close(...future.stdout)
  [07:16:41.953]         ...future.stdout <- NULL
  [07:16:41.953]     }
  [07:16:41.953]     ...future.result$conditions <- ...future.conditions
  [07:16:41.953]     ...future.result
  [07:16:41.953] }
  [07:16:41.956] requestCore(): workers = 2
  [07:16:41.960] MulticoreFuture started
  [07:16:41.963] plan(): Setting new future strategy stack:
  [07:16:41.963] List of future strategies:
  [07:16:41.963] 1. sequential:
  [07:16:41.963]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:41.963]    - tweaked: FALSE
  [07:16:41.963]    - call: NULL
  [07:16:41.965] plan(): nbrOfWorkers() = 1
  [07:16:41.968] Packages needed by the future expression (n = 0): <none>
  [07:16:41.969] Packages needed by future strategies (n = 0): <none>
  [07:16:41.974] plan(): Setting new future strategy stack:
  [07:16:41.974] List of future strategies:
  [07:16:41.974] 1. multicore:
  [07:16:41.974]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:16:41.974]    - tweaked: FALSE
  [07:16:41.974]    - call: plan(strategy)
  [07:16:41.977] plan(): nbrOfWorkers() = 2
  [07:16:41.983] {
  [07:16:41.983]     {
  [07:16:41.983]         ...future.startTime <- base::Sys.time()
  [07:16:41.983]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:41.983]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:41.983]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:41.983]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:41.983]             future.resolve.recursive = NULL, width = 80L)
  [07:16:41.983]         {
  [07:16:41.983]             {
  [07:16:41.983]                 {
  [07:16:41.983]                   base::local({
  [07:16:41.983]                     has_future <- base::requireNamespace("future", 
  [07:16:41.983]                       quietly = TRUE)
  [07:16:41.983]                     version <- if (has_future) 
  [07:16:41.983]                       utils::packageVersion("future")
  [07:16:41.983]                     else NULL
  [07:16:41.983]                     if (!has_future || version < "1.8.0") {
  [07:16:41.983]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:16:41.983]                         "", base::R.version$version.string), 
  [07:16:41.983]                         platform = base::sprintf("%s (%s-bit)", 
  [07:16:41.983]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:41.983]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:41.983]                           "release", "version")], collapse = " "), 
  [07:16:41.983]                         hostname = base::Sys.info()[["nodename"]])
  [07:16:41.983]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:41.983]                         info)
  [07:16:41.983]                       info <- base::paste(info, collapse = "; ")
  [07:16:41.983]                       if (!has_future) {
  [07:16:41.983]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:41.983]                           info)
  [07:16:41.983]                       }
  [07:16:41.983]                       else {
  [07:16:41.983]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:41.983]                           info, version)
  [07:16:41.983]                       }
  [07:16:41.983]                       base::stop(msg)
  [07:16:41.983]                     }
  [07:16:41.983]                   })
  [07:16:41.983]                 }
  [07:16:41.983]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:16:41.983]                 base::options(mc.cores = 1L)
  [07:16:41.983]             }
  [07:16:41.983]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:41.983]         }
  [07:16:41.983]     }
  [07:16:41.983]     if (base::is.na(TRUE)) {
  [07:16:41.983]     }
  [07:16:41.983]     else {
  [07:16:41.983]         if (TRUE) {
  [07:16:41.983]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:41.983]                 open = "w")
  [07:16:41.983]         }
  [07:16:41.983]         else {
  [07:16:41.983]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:41.983]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:41.983]         }
  [07:16:41.983]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:41.983]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:41.983]             base::sink(type = "output", split = FALSE)
  [07:16:41.983]             base::close(...future.stdout)
  [07:16:41.983]         }, add = TRUE)
  [07:16:41.983]     }
  [07:16:41.983]     ...future.frame <- base::sys.nframe()
  [07:16:41.983]     ...future.conditions <- base::list()
  [07:16:41.983]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:41.983]     ...future.result <- base::tryCatch({
  [07:16:41.983]         base::withCallingHandlers({
  [07:16:41.983]             ...future.value <- base::withVisible(base::local({
  [07:16:41.983]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:16:41.983]                   ii, n), appendLF = FALSE)
  [07:16:41.983]                 fit <- mandelbrot(C)
  [07:16:41.983]                 delay(fit)
  [07:16:41.983]                 message(" done")
  [07:16:41.983]                 fit
  [07:16:41.983]             }))
  [07:16:41.983]             future::FutureResult(value = ...future.value$value, 
  [07:16:41.983]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.983]                   ...future.rng), started = ...future.startTime, 
  [07:16:41.983]                 version = "1.8")
  [07:16:41.983]         }, condition = base::local({
  [07:16:41.983]             c <- base::c
  [07:16:41.983]             inherits <- base::inherits
  [07:16:41.983]             invokeRestart <- base::invokeRestart
  [07:16:41.983]             length <- base::length
  [07:16:41.983]             list <- base::list
  [07:16:41.983]             seq.int <- base::seq.int
  [07:16:41.983]             signalCondition <- base::signalCondition
  [07:16:41.983]             sys.calls <- base::sys.calls
  [07:16:41.983]             Sys.time <- base::Sys.time
  [07:16:41.983]             `[[` <- base::`[[`
  [07:16:41.983]             `+` <- base::`+`
  [07:16:41.983]             `<<-` <- base::`<<-`
  [07:16:41.983]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:41.983]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:41.983]                   3L)]
  [07:16:41.983]             }
  [07:16:41.983]             function(cond) {
  [07:16:41.983]                 if (inherits(cond, "error")) {
  [07:16:41.983]                   sessionInformation <- function() {
  [07:16:41.983]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:41.983]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:41.983]                       search = base::search(), system = base::Sys.info())
  [07:16:41.983]                   }
  [07:16:41.983]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.983]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:41.983]                     cond$call), session = sessionInformation(), 
  [07:16:41.983]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:41.983]                   signalCondition(cond)
  [07:16:41.983]                 }
  [07:16:41.983]                 else if (inherits(cond, "condition")) {
  [07:16:41.983]                   signal <- FALSE && inherits(cond, character(0))
  [07:16:41.983]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:41.983]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:41.983]                   if (!signal) {
  [07:16:41.983]                     muffleCondition <- function (cond) 
  [07:16:41.983]                     {
  [07:16:41.983]                       inherits <- base::inherits
  [07:16:41.983]                       invokeRestart <- base::invokeRestart
  [07:16:41.983]                       muffled <- FALSE
  [07:16:41.983]                       if (inherits(cond, "message")) {
  [07:16:41.983]                         invokeRestart("muffleMessage")
  [07:16:41.983]                         muffled <- TRUE
  [07:16:41.983]                       }
  [07:16:41.983]                       else if (inherits(cond, "warning")) {
  [07:16:41.983]                         invokeRestart("muffleWarning")
  [07:16:41.983]                         muffled <- TRUE
  [07:16:41.983]                       }
  [07:16:41.983]                       else if (inherits(cond, "condition")) {
  [07:16:41.983]                         computeRestarts <- base::computeRestarts
  [07:16:41.983]                         grepl <- base::grepl
  [07:16:41.983]                         is.null <- base::is.null
  [07:16:41.983]                         restarts <- computeRestarts(cond)
  [07:16:41.983]                         for (restart in restarts) {
  [07:16:41.983]                           name <- restart$name
  [07:16:41.983]                           if (is.null(name)) 
  [07:16:41.983]                             next
  [07:16:41.983]                           if (!grepl("^muffle", name)) 
  [07:16:41.983]                             next
  [07:16:41.983]                           invokeRestart(restart)
  [07:16:41.983]                           muffled <- TRUE
  [07:16:41.983]                           break
  [07:16:41.983]                         }
  [07:16:41.983]                       }
  [07:16:41.983]                       invisible(muffled)
  [07:16:41.983]                     }
  [07:16:41.983]                     muffleCondition(cond)
  [07:16:41.983]                   }
  [07:16:41.983]                 }
  [07:16:41.983]             }
  [07:16:41.983]         }))
  [07:16:41.983]     }, error = function(ex) {
  [07:16:41.983]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:41.983]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:41.983]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:41.983]     }, finally = {
  [07:16:41.983]         {
  [07:16:41.983]             {
  [07:16:41.983]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:16:41.983]             }
  [07:16:41.983]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:41.983]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:41.983]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:16:41.983]                 earlySignal = FALSE, label = NULL, ...) 
  [07:16:41.983]             {
  [07:16:41.983]                 if (substitute) 
  [07:16:41.983]                   expr <- substitute(expr)
  [07:16:41.983]                 if (is.function(workers)) 
  [07:16:41.983]                   workers <- workers()
  [07:16:41.983]                 workers <- as.integer(workers)
  [07:16:41.983]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:16:41.983]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:16:41.983]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:16:41.983]                     lazy = lazy, seed = seed, globals = globals, 
  [07:16:41.983]                     local = TRUE, label = label, ...))
  [07:16:41.983]                 }
  [07:16:41.983]                 oopts <- options(mc.cores = workers)
  [07:16:41.983]                 on.exit(options(oopts))
  [07:16:41.983]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:16:41.983]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:41.983]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:16:41.983]                   label = label, ...)
  [07:16:41.983]                 if (!future$lazy) 
  [07:16:41.983]                   future <- run(future)
  [07:16:41.983]                 invisible(future)
  [07:16:41.983]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:41.983]         }
  [07:16:41.983]         base::options(...future.oldOptions)
  [07:16:41.983]     })
  [07:16:41.983]     Sys.time
  [07:16:41.983]     if (base::is.na(TRUE)) {
  [07:16:41.983]     }
  [07:16:41.983]     else {
  [07:16:41.983]         base::sink(type = "output", split = FALSE)
  [07:16:41.983]         if (TRUE) {
  [07:16:41.983]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:41.983]         }
  [07:16:41.983]         else {
  [07:16:41.983]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:41.983]         }
  [07:16:41.983]         base::close(...future.stdout)
  [07:16:41.983]         ...future.stdout <- NULL
  [07:16:41.983]     }
  [07:16:41.983]     ...future.result$conditions <- ...future.conditions
  [07:16:41.983]     ...future.result
  [07:16:41.983] }
  [07:16:41.987] requestCore(): workers = 2
  [07:16:41.998] MulticoreFuture started
  [07:16:42.002] plan(): Setting new future strategy stack:
  Plotting tile #1 of 4 ...
  [07:16:42.003] List of future strategies:
  [07:16:42.003] 1. sequential:
  [07:16:42.003]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:42.003]    - tweaked: FALSE
  [07:16:42.003]    - call: NULL
  [07:16:42.004] plan(): nbrOfWorkers() = 1
  [07:16:42.008] signalConditions() ...
  [07:16:42.009]  - include = 'immediateCondition'
  [07:16:42.009]  - exclude = 
  [07:16:42.009]  - resignal = FALSE
  [07:16:42.010]  - Number of conditions: 2
  [07:16:42.010] signalConditions() ... done
  [07:16:42.010] signalConditions() ...
  [07:16:42.011] plan(): Setting new future strategy stack:
  [07:16:42.011]  - include = 'immediateCondition'
  [07:16:42.011]  - exclude = 
  [07:16:42.012]  - resignal = FALSE
  [07:16:42.011] List of future strategies:
  [07:16:42.011] 1. multicore:
  [07:16:42.011]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:16:42.011]    - tweaked: FALSE
  [07:16:42.011]    - call: plan(strategy)
  [07:16:42.012]  - Number of conditions: 2
  [07:16:42.012] signalConditions() ... done
  [07:16:42.013] Future state: 'finished'
  [07:16:42.013] plan(): nbrOfWorkers() = 2
  [07:16:42.013] signalConditions() ...
  [07:16:42.013]  - include = 'condition'
  [07:16:42.014]  - exclude = 'immediateCondition'
  [07:16:42.014]  - resignal = TRUE
  [07:16:42.014]  - Number of conditions: 2
  [07:16:42.015]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #1 of 4 ...[07:16:42.015]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:16:42.016] signalConditions() ... done
  Plotting tile #2 of 4 ...
  [07:16:42.019] signalConditions() ...
  [07:16:42.019]  - include = 'immediateCondition'
  [07:16:42.020]  - exclude = 
  [07:16:42.020]  - resignal = FALSE
  [07:16:42.020]  - Number of conditions: 2
  [07:16:42.021] signalConditions() ... done
  [07:16:42.021] signalConditions() ...
  [07:16:42.021]  - include = 'immediateCondition'
  [07:16:42.021]  - exclude = 
  [07:16:42.022]  - resignal = FALSE
  [07:16:42.022]  - Number of conditions: 2
  [07:16:42.022] signalConditions() ... done
  [07:16:42.023] Future state: 'finished'
  [07:16:42.023] signalConditions() ...
  [07:16:42.023]  - include = 'condition'
  [07:16:42.023]  - exclude = 'immediateCondition'
  [07:16:42.024]  - resignal = TRUE
  [07:16:42.024]  - Number of conditions: 2
  [07:16:42.024]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #2 of 4 ...[07:16:42.025]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:16:42.025] signalConditions() ... done
  [07:16:42.028] Packages needed by the future expression (n = 0): <none>
  [07:16:42.028] Packages needed by future strategies (n = 0): <none>
  [07:16:42.032] {
  [07:16:42.032]     {
  [07:16:42.032]         ...future.startTime <- base::Sys.time()
  [07:16:42.032]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:42.032]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:42.032]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:42.032]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:42.032]             future.resolve.recursive = NULL, width = 80L)
  [07:16:42.032]         {
  [07:16:42.032]             {
  [07:16:42.032]                 {
  [07:16:42.032]                   base::local({
  [07:16:42.032]                     has_future <- base::requireNamespace("future", 
  [07:16:42.032]                       quietly = TRUE)
  [07:16:42.032]                     version <- if (has_future) 
  [07:16:42.032]                       utils::packageVersion("future")
  [07:16:42.032]                     else NULL
  [07:16:42.032]                     if (!has_future || version < "1.8.0") {
  [07:16:42.032]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:16:42.032]                         "", base::R.version$version.string), 
  [07:16:42.032]                         platform = base::sprintf("%s (%s-bit)", 
  [07:16:42.032]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:42.032]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:42.032]                           "release", "version")], collapse = " "), 
  [07:16:42.032]                         hostname = base::Sys.info()[["nodename"]])
  [07:16:42.032]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:42.032]                         info)
  [07:16:42.032]                       info <- base::paste(info, collapse = "; ")
  [07:16:42.032]                       if (!has_future) {
  [07:16:42.032]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:42.032]                           info)
  [07:16:42.032]                       }
  [07:16:42.032]                       else {
  [07:16:42.032]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:42.032]                           info, version)
  [07:16:42.032]                       }
  [07:16:42.032]                       base::stop(msg)
  [07:16:42.032]                     }
  [07:16:42.032]                   })
  [07:16:42.032]                 }
  [07:16:42.032]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:16:42.032]                 base::options(mc.cores = 1L)
  [07:16:42.032]             }
  [07:16:42.032]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:42.032]         }
  [07:16:42.032]     }
  [07:16:42.032]     if (base::is.na(TRUE)) {
  [07:16:42.032]     }
  [07:16:42.032]     else {
  [07:16:42.032]         if (TRUE) {
  [07:16:42.032]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:42.032]                 open = "w")
  [07:16:42.032]         }
  [07:16:42.032]         else {
  [07:16:42.032]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:42.032]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:42.032]         }
  [07:16:42.032]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:42.032]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:42.032]             base::sink(type = "output", split = FALSE)
  [07:16:42.032]             base::close(...future.stdout)
  [07:16:42.032]         }, add = TRUE)
  [07:16:42.032]     }
  [07:16:42.032]     ...future.frame <- base::sys.nframe()
  [07:16:42.032]     ...future.conditions <- base::list()
  [07:16:42.032]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:42.032]     ...future.result <- base::tryCatch({
  [07:16:42.032]         base::withCallingHandlers({
  [07:16:42.032]             ...future.value <- base::withVisible(base::local({
  [07:16:42.032]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:16:42.032]                   ii, n), appendLF = FALSE)
  [07:16:42.032]                 fit <- mandelbrot(C)
  [07:16:42.032]                 delay(fit)
  [07:16:42.032]                 message(" done")
  [07:16:42.032]                 fit
  [07:16:42.032]             }))
  [07:16:42.032]             future::FutureResult(value = ...future.value$value, 
  [07:16:42.032]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:42.032]                   ...future.rng), started = ...future.startTime, 
  [07:16:42.032]                 version = "1.8")
  [07:16:42.032]         }, condition = base::local({
  [07:16:42.032]             c <- base::c
  [07:16:42.032]             inherits <- base::inherits
  [07:16:42.032]             invokeRestart <- base::invokeRestart
  [07:16:42.032]             length <- base::length
  [07:16:42.032]             list <- base::list
  [07:16:42.032]             seq.int <- base::seq.int
  [07:16:42.032]             signalCondition <- base::signalCondition
  [07:16:42.032]             sys.calls <- base::sys.calls
  [07:16:42.032]             Sys.time <- base::Sys.time
  [07:16:42.032]             `[[` <- base::`[[`
  [07:16:42.032]             `+` <- base::`+`
  [07:16:42.032]             `<<-` <- base::`<<-`
  [07:16:42.032]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:42.032]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:42.032]                   3L)]
  [07:16:42.032]             }
  [07:16:42.032]             function(cond) {
  [07:16:42.032]                 if (inherits(cond, "error")) {
  [07:16:42.032]                   sessionInformation <- function() {
  [07:16:42.032]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:42.032]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:42.032]                       search = base::search(), system = base::Sys.info())
  [07:16:42.032]                   }
  [07:16:42.032]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:42.032]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:42.032]                     cond$call), session = sessionInformation(), 
  [07:16:42.032]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:42.032]                   signalCondition(cond)
  [07:16:42.032]                 }
  [07:16:42.032]                 else if (inherits(cond, "condition")) {
  [07:16:42.032]                   signal <- FALSE && inherits(cond, character(0))
  [07:16:42.032]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:42.032]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:42.032]                   if (!signal) {
  [07:16:42.032]                     muffleCondition <- function (cond) 
  [07:16:42.032]                     {
  [07:16:42.032]                       inherits <- base::inherits
  [07:16:42.032]                       invokeRestart <- base::invokeRestart
  [07:16:42.032]                       muffled <- FALSE
  [07:16:42.032]                       if (inherits(cond, "message")) {
  [07:16:42.032]                         invokeRestart("muffleMessage")
  [07:16:42.032]                         muffled <- TRUE
  [07:16:42.032]                       }
  [07:16:42.032]                       else if (inherits(cond, "warning")) {
  [07:16:42.032]                         invokeRestart("muffleWarning")
  [07:16:42.032]                         muffled <- TRUE
  [07:16:42.032]                       }
  [07:16:42.032]                       else if (inherits(cond, "condition")) {
  [07:16:42.032]                         computeRestarts <- base::computeRestarts
  [07:16:42.032]                         grepl <- base::grepl
  [07:16:42.032]                         is.null <- base::is.null
  [07:16:42.032]                         restarts <- computeRestarts(cond)
  [07:16:42.032]                         for (restart in restarts) {
  [07:16:42.032]                           name <- restart$name
  [07:16:42.032]                           if (is.null(name)) 
  [07:16:42.032]                             next
  [07:16:42.032]                           if (!grepl("^muffle", name)) 
  [07:16:42.032]                             next
  [07:16:42.032]                           invokeRestart(restart)
  [07:16:42.032]                           muffled <- TRUE
  [07:16:42.032]                           break
  [07:16:42.032]                         }
  [07:16:42.032]                       }
  [07:16:42.032]                       invisible(muffled)
  [07:16:42.032]                     }
  [07:16:42.032]                     muffleCondition(cond)
  [07:16:42.032]                   }
  [07:16:42.032]                 }
  [07:16:42.032]             }
  [07:16:42.032]         }))
  [07:16:42.032]     }, error = function(ex) {
  [07:16:42.032]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:42.032]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:42.032]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:42.032]     }, finally = {
  [07:16:42.032]         {
  [07:16:42.032]             {
  [07:16:42.032]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:16:42.032]             }
  [07:16:42.032]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:42.032]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:42.032]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:16:42.032]                 earlySignal = FALSE, label = NULL, ...) 
  [07:16:42.032]             {
  [07:16:42.032]                 if (substitute) 
  [07:16:42.032]                   expr <- substitute(expr)
  [07:16:42.032]                 if (is.function(workers)) 
  [07:16:42.032]                   workers <- workers()
  [07:16:42.032]                 workers <- as.integer(workers)
  [07:16:42.032]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:16:42.032]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:16:42.032]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:16:42.032]                     lazy = lazy, seed = seed, globals = globals, 
  [07:16:42.032]                     local = TRUE, label = label, ...))
  [07:16:42.032]                 }
  [07:16:42.032]                 oopts <- options(mc.cores = workers)
  [07:16:42.032]                 on.exit(options(oopts))
  [07:16:42.032]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:16:42.032]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:42.032]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:16:42.032]                   label = label, ...)
  [07:16:42.032]                 if (!future$lazy) 
  [07:16:42.032]                   future <- run(future)
  [07:16:42.032]                 invisible(future)
  [07:16:42.032]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:42.032]         }
  [07:16:42.032]         base::options(...future.oldOptions)
  [07:16:42.032]     })
  [07:16:42.032]     Sys.time
  [07:16:42.032]     if (base::is.na(TRUE)) {
  [07:16:42.032]     }
  [07:16:42.032]     else {
  [07:16:42.032]         base::sink(type = "output", split = FALSE)
  [07:16:42.032]         if (TRUE) {
  [07:16:42.032]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:42.032]         }
  [07:16:42.032]         else {
  [07:16:42.032]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:42.032]         }
  [07:16:42.032]         base::close(...future.stdout)
  [07:16:42.032]         ...future.stdout <- NULL
  [07:16:42.032]     }
  [07:16:42.032]     ...future.result$conditions <- ...future.conditions
  [07:16:42.032]     ...future.result
  [07:16:42.032] }
  [07:16:42.036] requestCore(): workers = 2
  [07:16:42.038] MulticoreFuture started
  [07:16:42.041] plan(): Setting new future strategy stack:
  [07:16:42.041] Packages needed by the future expression (n = 0): <none>
  [07:16:42.042] Packages needed by future strategies (n = 0): <none>
  [07:16:42.042] List of future strategies:
  [07:16:42.042] 1. sequential:
  [07:16:42.042]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:42.042]    - tweaked: FALSE
  [07:16:42.042]    - call: NULL
  [07:16:42.043] plan(): nbrOfWorkers() = 1
  [07:16:42.047] plan(): Setting new future strategy stack:
  [07:16:42.047] List of future strategies:
  [07:16:42.047] 1. multicore:
  [07:16:42.047]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:16:42.047]    - tweaked: FALSE
  [07:16:42.047]    - call: plan(strategy)
  [07:16:42.049] plan(): nbrOfWorkers() = 2
  [07:16:42.058] {
  [07:16:42.058]     {
  [07:16:42.058]         ...future.startTime <- base::Sys.time()
  [07:16:42.058]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:16:42.058]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:16:42.058]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:16:42.058]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:16:42.058]             future.resolve.recursive = NULL, width = 80L)
  [07:16:42.058]         {
  [07:16:42.058]             {
  [07:16:42.058]                 {
  [07:16:42.058]                   base::local({
  [07:16:42.058]                     has_future <- base::requireNamespace("future", 
  [07:16:42.058]                       quietly = TRUE)
  [07:16:42.058]                     version <- if (has_future) 
  [07:16:42.058]                       utils::packageVersion("future")
  [07:16:42.058]                     else NULL
  [07:16:42.058]                     if (!has_future || version < "1.8.0") {
  [07:16:42.058]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:16:42.058]                         "", base::R.version$version.string), 
  [07:16:42.058]                         platform = base::sprintf("%s (%s-bit)", 
  [07:16:42.058]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:16:42.058]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:16:42.058]                           "release", "version")], collapse = " "), 
  [07:16:42.058]                         hostname = base::Sys.info()[["nodename"]])
  [07:16:42.058]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:16:42.058]                         info)
  [07:16:42.058]                       info <- base::paste(info, collapse = "; ")
  [07:16:42.058]                       if (!has_future) {
  [07:16:42.058]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:16:42.058]                           info)
  [07:16:42.058]                       }
  [07:16:42.058]                       else {
  [07:16:42.058]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:16:42.058]                           info, version)
  [07:16:42.058]                       }
  [07:16:42.058]                       base::stop(msg)
  [07:16:42.058]                     }
  [07:16:42.058]                   })
  [07:16:42.058]                 }
  [07:16:42.058]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:16:42.058]                 base::options(mc.cores = 1L)
  [07:16:42.058]             }
  [07:16:42.058]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:16:42.058]         }
  [07:16:42.058]     }
  [07:16:42.058]     if (base::is.na(TRUE)) {
  [07:16:42.058]     }
  [07:16:42.058]     else {
  [07:16:42.058]         if (TRUE) {
  [07:16:42.058]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:16:42.058]                 open = "w")
  [07:16:42.058]         }
  [07:16:42.058]         else {
  [07:16:42.058]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:16:42.058]                 windows = "NUL", "/dev/null"), open = "w")
  [07:16:42.058]         }
  [07:16:42.058]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:16:42.058]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:16:42.058]             base::sink(type = "output", split = FALSE)
  [07:16:42.058]             base::close(...future.stdout)
  [07:16:42.058]         }, add = TRUE)
  [07:16:42.058]     }
  [07:16:42.058]     ...future.frame <- base::sys.nframe()
  [07:16:42.058]     ...future.conditions <- base::list()
  [07:16:42.058]     ...future.rng <- base::globalenv()$.Random.seed
  [07:16:42.058]     ...future.result <- base::tryCatch({
  [07:16:42.058]         base::withCallingHandlers({
  [07:16:42.058]             ...future.value <- base::withVisible(base::local({
  [07:16:42.058]                 message(sprintf("Calculating tile #%d of %d ...", 
  [07:16:42.058]                   ii, n), appendLF = FALSE)
  [07:16:42.058]                 fit <- mandelbrot(C)
  [07:16:42.058]                 delay(fit)
  [07:16:42.058]                 message(" done")
  [07:16:42.058]                 fit
  [07:16:42.058]             }))
  [07:16:42.058]             future::FutureResult(value = ...future.value$value, 
  [07:16:42.058]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:42.058]                   ...future.rng), started = ...future.startTime, 
  [07:16:42.058]                 version = "1.8")
  [07:16:42.058]         }, condition = base::local({
  [07:16:42.058]             c <- base::c
  [07:16:42.058]             inherits <- base::inherits
  [07:16:42.058]             invokeRestart <- base::invokeRestart
  [07:16:42.058]             length <- base::length
  [07:16:42.058]             list <- base::list
  [07:16:42.058]             seq.int <- base::seq.int
  [07:16:42.058]             signalCondition <- base::signalCondition
  [07:16:42.058]             sys.calls <- base::sys.calls
  [07:16:42.058]             Sys.time <- base::Sys.time
  [07:16:42.058]             `[[` <- base::`[[`
  [07:16:42.058]             `+` <- base::`+`
  [07:16:42.058]             `<<-` <- base::`<<-`
  [07:16:42.058]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:16:42.058]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:16:42.058]                   3L)]
  [07:16:42.058]             }
  [07:16:42.058]             function(cond) {
  [07:16:42.058]                 if (inherits(cond, "error")) {
  [07:16:42.058]                   sessionInformation <- function() {
  [07:16:42.058]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:16:42.058]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:16:42.058]                       search = base::search(), system = base::Sys.info())
  [07:16:42.058]                   }
  [07:16:42.058]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:42.058]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:16:42.058]                     cond$call), session = sessionInformation(), 
  [07:16:42.058]                     timestamp = Sys.time(), signaled = 0L)
  [07:16:42.058]                   signalCondition(cond)
  [07:16:42.058]                 }
  [07:16:42.058]                 else if (inherits(cond, "condition")) {
  [07:16:42.058]                   signal <- FALSE && inherits(cond, character(0))
  [07:16:42.058]                   ...future.conditions[[length(...future.conditions) + 
  [07:16:42.058]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:16:42.058]                   if (!signal) {
  [07:16:42.058]                     muffleCondition <- function (cond) 
  [07:16:42.058]                     {
  [07:16:42.058]                       inherits <- base::inherits
  [07:16:42.058]                       invokeRestart <- base::invokeRestart
  [07:16:42.058]                       muffled <- FALSE
  [07:16:42.058]                       if (inherits(cond, "message")) {
  [07:16:42.058]                         invokeRestart("muffleMessage")
  [07:16:42.058]                         muffled <- TRUE
  [07:16:42.058]                       }
  [07:16:42.058]                       else if (inherits(cond, "warning")) {
  [07:16:42.058]                         invokeRestart("muffleWarning")
  [07:16:42.058]                         muffled <- TRUE
  [07:16:42.058]                       }
  [07:16:42.058]                       else if (inherits(cond, "condition")) {
  [07:16:42.058]                         computeRestarts <- base::computeRestarts
  [07:16:42.058]                         grepl <- base::grepl
  [07:16:42.058]                         is.null <- base::is.null
  [07:16:42.058]                         restarts <- computeRestarts(cond)
  [07:16:42.058]                         for (restart in restarts) {
  [07:16:42.058]                           name <- restart$name
  [07:16:42.058]                           if (is.null(name)) 
  [07:16:42.058]                             next
  [07:16:42.058]                           if (!grepl("^muffle", name)) 
  [07:16:42.058]                             next
  [07:16:42.058]                           invokeRestart(restart)
  [07:16:42.058]                           muffled <- TRUE
  [07:16:42.058]                           break
  [07:16:42.058]                         }
  [07:16:42.058]                       }
  [07:16:42.058]                       invisible(muffled)
  [07:16:42.058]                     }
  [07:16:42.058]                     muffleCondition(cond)
  [07:16:42.058]                   }
  [07:16:42.058]                 }
  [07:16:42.058]             }
  [07:16:42.058]         }))
  [07:16:42.058]     }, error = function(ex) {
  [07:16:42.058]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:16:42.058]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:16:42.058]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:16:42.058]     }, finally = {
  [07:16:42.058]         {
  [07:16:42.058]             {
  [07:16:42.058]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:16:42.058]             }
  [07:16:42.058]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:16:42.058]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:16:42.058]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:16:42.058]                 earlySignal = FALSE, label = NULL, ...) 
  [07:16:42.058]             {
  [07:16:42.058]                 if (substitute) 
  [07:16:42.058]                   expr <- substitute(expr)
  [07:16:42.058]                 if (is.function(workers)) 
  [07:16:42.058]                   workers <- workers()
  [07:16:42.058]                 workers <- as.integer(workers)
  [07:16:42.058]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:16:42.058]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:16:42.058]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:16:42.058]                     lazy = lazy, seed = seed, globals = globals, 
  [07:16:42.058]                     local = TRUE, label = label, ...))
  [07:16:42.058]                 }
  [07:16:42.058]                 oopts <- options(mc.cores = workers)
  [07:16:42.058]                 on.exit(options(oopts))
  [07:16:42.058]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:16:42.058]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:16:42.058]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:16:42.058]                   label = label, ...)
  [07:16:42.058]                 if (!future$lazy) 
  [07:16:42.058]                   future <- run(future)
  [07:16:42.058]                 invisible(future)
  [07:16:42.058]             }), .cleanup = FALSE, .init = FALSE)
  [07:16:42.058]         }
  [07:16:42.058]         base::options(...future.oldOptions)
  [07:16:42.058]     })
  [07:16:42.058]     Sys.time
  [07:16:42.058]     if (base::is.na(TRUE)) {
  [07:16:42.058]     }
  [07:16:42.058]     else {
  [07:16:42.058]         base::sink(type = "output", split = FALSE)
  [07:16:42.058]         if (TRUE) {
  [07:16:42.058]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:16:42.058]         }
  [07:16:42.058]         else {
  [07:16:42.058]             ...future.result["stdout"] <- base::list(NULL)
  [07:16:42.058]         }
  [07:16:42.058]         base::close(...future.stdout)
  [07:16:42.058]         ...future.stdout <- NULL
  [07:16:42.058]     }
  [07:16:42.058]     ...future.result$conditions <- ...future.conditions
  [07:16:42.058]     ...future.result
  [07:16:42.058] }
  [07:16:42.063] requestCore(): workers = 2
  [07:16:42.067] MulticoreFuture started
  Plotting tile #3 of 4 ...
  [07:16:42.073] plan(): Setting new future strategy stack:
  [07:16:42.074] signalConditions() ...
  [07:16:42.075]  - include = 'immediateCondition'
  [07:16:42.074] List of future strategies:
  [07:16:42.074] 1. sequential:
  [07:16:42.074]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:16:42.074]    - tweaked: FALSE
  [07:16:42.074]    - call: NULL
  [07:16:42.075]  - exclude = 
  [07:16:42.076]  - resignal = FALSE
  [07:16:42.076] plan(): nbrOfWorkers() = 1
  [07:16:42.077]  - Number of conditions: 2
  [07:16:42.077] signalConditions() ... done
  [07:16:42.078] signalConditions() ...
  [07:16:42.078]  - include = 'immediateCondition'
  [07:16:42.079]  - exclude = 
  [07:16:42.079]  - resignal = FALSE
  [07:16:42.080]  - Number of conditions: 2
  [07:16:42.081] signalConditions() ... done
  [07:16:42.081] Future state: 'finished'
  [07:16:42.082] signalConditions() ...
  [07:16:42.082]  - include = 'condition'
  [07:16:42.083]  - exclude = 'immediateCondition'
  [07:16:42.083]  - resignal = TRUE
  [07:16:42.084]  - Number of conditions: 2
  [07:16:42.084] plan(): Setting new future strategy stack:
  [07:16:42.084]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #3 of 4 ...[07:16:42.085]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:16:42.085] List of future strategies:
  [07:16:42.085] 1. multicore:
  [07:16:42.085]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:16:42.085]    - tweaked: FALSE
  [07:16:42.085]    - call: plan(strategy)
  [07:16:42.086] signalConditions() ... done
  [07:16:42.087] plan(): nbrOfWorkers() = 2
  Plotting tile #4 of 4 ...
  [07:16:42.090] signalConditions() ...
  [07:16:42.090]  - include = 'immediateCondition'
  [07:16:42.091]  - exclude = 
  [07:16:42.091]  - resignal = FALSE
  [07:16:42.091]  - Number of conditions: 2
  [07:16:42.092] signalConditions() ... done
  [07:16:42.092] signalConditions() ...
  [07:16:42.092]  - include = 'immediateCondition'
  [07:16:42.093]  - exclude = 
  [07:16:42.093]  - resignal = FALSE
  [07:16:42.093]  - Number of conditions: 2
  [07:16:42.093] signalConditions() ... done
  [07:16:42.094] Future state: 'finished'
  [07:16:42.094] signalConditions() ...
  [07:16:42.094]  - include = 'condition'
  [07:16:42.094]  - exclude = 'immediateCondition'
  [07:16:42.095]  - resignal = TRUE
  [07:16:42.095]  - Number of conditions: 2
  [07:16:42.095]  - Condition #1: 'simpleMessage', 'message', 'condition'
  Calculating tile #4 of 4 ...[07:16:42.095]  - Condition #2: 'simpleMessage', 'message', 'condition'
   done
  [07:16:42.096] 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:16:42.099] plan(): Setting new future strategy stack:
  [07:16:42.099] List of future strategies:
  [07:16:42.099] 1. multisession:
  [07:16:42.099]    - 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:16:42.099]    - tweaked: FALSE
  [07:16:42.099]    - call: plan(strategy)
  [07:16:42.100] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [07:16:42.100] multisession:
  [07:16:42.100] - 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:16:42.100] - tweaked: FALSE
  [07:16:42.100] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 23241
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/data/gannet/ripley/R/R-clang/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpZt0vos/future.parent=698579.aa8d366815258.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmpi2dwzg/working_dir/RtmpZt0vos/future.parent=698579.aa8d366815258.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/demo.R:gannet.stats.ox.ac.uk:ripley:698579' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpZt0vos/future.parent=698579.aa8d366815258.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=23241 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 698621) if still alive
  [07:18:42.932] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(698579, signal = 0L)
  [1] TRUE
  Call: tools::pskill(698579, signal = 0L)
  [1] TRUE
  [07:18:42.933] - success
  [07:18:42.934] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 698621) 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 23241 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/demo.R:gannet.stats.ox.ac.uk:ripley:698579' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpZt0vos/future.parent=698579.aa8d366815258.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=23241 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 698621) 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:18:43.303] plan(): Setting new future strategy stack:
  [07:18:43.304] List of future strategies:
  [07:18:43.304] 1. sequential:
  [07:18:43.304]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:18:43.304]    - tweaked: FALSE
  [07:18:43.304]    - call: future::plan("sequential")
  [07:18:43.305] 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:18:43.390] plan(): Setting new future strategy stack:
  [07:18:43.390] List of future strategies:
  [07:18:43.390] 1. sequential:
  [07:18:43.390]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:18:43.390]    - tweaked: FALSE
  [07:18:43.390]    - call: plan(strategy, substitute = FALSE)
  [07:18:43.408] plan(): nbrOfWorkers() = 1
  ** Sum function 'A' with plan('sequential') ...
  function (x, ...) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, ...)
      }
      y
  }
  <bytecode: 0x42964a8>
  Arguments '...' exists: TRUE
  [07:18:43.411] getGlobalsAndPackages() ...
  [07:18:43.411] Searching for globals...
  [07:18:43.419] - globals found: [4] '{', 'sum', 'x', '...'
  [07:18:43.419] Searching for globals ... DONE
  [07:18:43.419] Resolving globals: FALSE
  [07:18:43.420] Tweak future expression to call with '...' arguments ...
  [07:18:43.420] Tweak future expression to call with '...' arguments ... DONE
  [07:18:43.422] The total size of the 2 globals is 112 bytes (112 bytes)
  [07:18:43.423] - globals: [2] 'x', 'future.call.arguments'
  [07:18:43.423] 
  [07:18:43.423] getGlobalsAndPackages() ... DONE
  [07:18:43.425] Packages needed by the future expression (n = 0): <none>
  [07:18:43.426] Packages needed by future strategies (n = 0): <none>
  [07:18:43.432] {
  [07:18:43.432]     {
  [07:18:43.432]         ...future.startTime <- base::Sys.time()
  [07:18:43.432]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:18:43.432]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:18:43.432]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:18:43.432]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:18:43.432]             future.resolve.recursive = NULL, width = 80L)
  [07:18:43.432]         {
  [07:18:43.432]             {
  [07:18:43.432]                 base::local({
  [07:18:43.432]                   has_future <- base::requireNamespace("future", 
  [07:18:43.432]                     quietly = TRUE)
  [07:18:43.432]                   version <- if (has_future) 
  [07:18:43.432]                     utils::packageVersion("future")
  [07:18:43.432]                   else NULL
  [07:18:43.432]                   if (!has_future || version < "1.8.0") {
  [07:18:43.432]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:18:43.432]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:18:43.432]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:18:43.432]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:18:43.432]                         "release", "version")], collapse = " "), 
  [07:18:43.432]                       hostname = base::Sys.info()[["nodename"]])
  [07:18:43.432]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:18:43.432]                       info)
  [07:18:43.432]                     info <- base::paste(info, collapse = "; ")
  [07:18:43.432]                     if (!has_future) {
  [07:18:43.432]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:18:43.432]                         info)
  [07:18:43.432]                     }
  [07:18:43.432]                     else {
  [07:18:43.432]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:18:43.432]                         info, version)
  [07:18:43.432]                     }
  [07:18:43.432]                     base::stop(msg)
  [07:18:43.432]                   }
  [07:18:43.432]                 })
  [07:18:43.432]             }
  [07:18:43.432]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:18:43.432]         }
  [07:18:43.432]     }
  [07:18:43.432]     if (base::is.na(TRUE)) {
  [07:18:43.432]     }
  [07:18:43.432]     else {
  [07:18:43.432]         if (TRUE) {
  [07:18:43.432]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:18:43.432]                 open = "w")
  [07:18:43.432]         }
  [07:18:43.432]         else {
  [07:18:43.432]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:18:43.432]                 windows = "NUL", "/dev/null"), open = "w")
  [07:18:43.432]         }
  [07:18:43.432]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:18:43.432]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:18:43.432]             base::sink(type = "output", split = FALSE)
  [07:18:43.432]             base::close(...future.stdout)
  [07:18:43.432]         }, add = TRUE)
  [07:18:43.432]     }
  [07:18:43.432]     ...future.frame <- base::sys.nframe()
  [07:18:43.432]     ...future.conditions <- base::list()
  [07:18:43.432]     ...future.rng <- base::globalenv()$.Random.seed
  [07:18:43.432]     ...future.result <- base::tryCatch({
  [07:18:43.432]         base::withCallingHandlers({
  [07:18:43.432]             ...future.value <- base::withVisible(base::local({
  [07:18:43.432]                 sum(x, ...)
  [07:18:43.432]             }))
  [07:18:43.432]             future::FutureResult(value = ...future.value$value, 
  [07:18:43.432]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:18:43.432]                   ...future.rng), started = ...future.startTime, 
  [07:18:43.432]                 version = "1.8")
  [07:18:43.432]         }, condition = base::local({
  [07:18:43.432]             c <- base::c
  [07:18:43.432]             inherits <- base::inherits
  [07:18:43.432]             invokeRestart <- base::invokeRestart
  [07:18:43.432]             length <- base::length
  [07:18:43.432]             list <- base::list
  [07:18:43.432]             seq.int <- base::seq.int
  [07:18:43.432]             signalCondition <- base::signalCondition
  [07:18:43.432]             sys.calls <- base::sys.calls
  [07:18:43.432]             Sys.time <- base::Sys.time
  [07:18:43.432]             `[[` <- base::`[[`
  [07:18:43.432]             `+` <- base::`+`
  [07:18:43.432]             `<<-` <- base::`<<-`
  [07:18:43.432]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:18:43.432]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:18:43.432]                   3L)]
  [07:18:43.432]             }
  [07:18:43.432]             function(cond) {
  [07:18:43.432]                 if (inherits(cond, "error")) {
  [07:18:43.432]                   sessionInformation <- function() {
  [07:18:43.432]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:18:43.432]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:18:43.432]                       search = base::search(), system = base::Sys.info())
  [07:18:43.432]                   }
  [07:18:43.432]                   ...future.conditions[[length(...future.conditions) + 
  [07:18:43.432]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:18:43.432]                     cond$call), session = sessionInformation(), 
  [07:18:43.432]                     timestamp = Sys.time(), signaled = 0L)
  [07:18:43.432]                   signalCondition(cond)
  [07:18:43.432]                 }
  [07:18:43.432]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:18:43.432]                 ))) {
  [07:18:43.432]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:18:43.432]                   ...future.conditions[[length(...future.conditions) + 
  [07:18:43.432]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:18:43.432]                   if (!signal) {
  [07:18:43.432]                     muffleCondition <- function (cond) 
  [07:18:43.432]                     {
  [07:18:43.432]                       inherits <- base::inherits
  [07:18:43.432]                       invokeRestart <- base::invokeRestart
  [07:18:43.432]                       muffled <- FALSE
  [07:18:43.432]                       if (inherits(cond, "message")) {
  [07:18:43.432]                         invokeRestart("muffleMessage")
  [07:18:43.432]                         muffled <- TRUE
  [07:18:43.432]                       }
  [07:18:43.432]                       else if (inherits(cond, "warning")) {
  [07:18:43.432]                         invokeRestart("muffleWarning")
  [07:18:43.432]                         muffled <- TRUE
  [07:18:43.432]                       }
  [07:18:43.432]                       else if (inherits(cond, "condition")) {
  [07:18:43.432]                         computeRestarts <- base::computeRestarts
  [07:18:43.432]                         grepl <- base::grepl
  [07:18:43.432]                         is.null <- base::is.null
  [07:18:43.432]                         restarts <- computeRestarts(cond)
  [07:18:43.432]                         for (restart in restarts) {
  [07:18:43.432]                           name <- restart$name
  [07:18:43.432]                           if (is.null(name)) 
  [07:18:43.432]                             next
  [07:18:43.432]                           if (!grepl("^muffle", name)) 
  [07:18:43.432]                             next
  [07:18:43.432]                           invokeRestart(restart)
  [07:18:43.432]                           muffled <- TRUE
  [07:18:43.432]                           break
  [07:18:43.432]                         }
  [07:18:43.432]                       }
  [07:18:43.432]                       invisible(muffled)
  [07:18:43.432]                     }
  [07:18:43.432]                     muffleCondition(cond)
  [07:18:43.432]                   }
  [07:18:43.432]                 }
  [07:18:43.432]             }
  [07:18:43.432]         }))
  [07:18:43.432]     }, error = function(ex) {
  [07:18:43.432]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:18:43.432]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:18:43.432]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:18:43.432]     }, finally = {
  [07:18:43.432]         {
  [07:18:43.432]             NULL
  [07:18:43.432]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:18:43.432]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:18:43.432]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:18:43.432]                 label = NULL, ...) 
  [07:18:43.432]             {
  [07:18:43.432]                 if (substitute) 
  [07:18:43.432]                   expr <- substitute(expr)
  [07:18:43.432]                 local <- as.logical(local)
  [07:18:43.432]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:18:43.432]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:18:43.432]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:18:43.432]                   label = label, ...)
  [07:18:43.432]                 if (!future$lazy) 
  [07:18:43.432]                   future <- run(future)
  [07:18:43.432]                 invisible(future)
  [07:18:43.432]             }), .cleanup = FALSE, .init = FALSE)
  [07:18:43.432]         }
  [07:18:43.432]         base::options(...future.oldOptions)
  [07:18:43.432]     })
  [07:18:43.432]     Sys.time
  [07:18:43.432]     if (base::is.na(TRUE)) {
  [07:18:43.432]     }
  [07:18:43.432]     else {
  [07:18:43.432]         base::sink(type = "output", split = FALSE)
  [07:18:43.432]         if (TRUE) {
  [07:18:43.432]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:18:43.432]         }
  [07:18:43.432]         else {
  [07:18:43.432]             ...future.result["stdout"] <- base::list(NULL)
  [07:18:43.432]         }
  [07:18:43.432]         base::close(...future.stdout)
  [07:18:43.432]         ...future.stdout <- NULL
  [07:18:43.432]     }
  [07:18:43.432]     ...future.result$conditions <- ...future.conditions
  [07:18:43.432]     ...future.result
  [07:18:43.432] }
  [07:18:43.436] plan(): Setting new future strategy stack:
  [07:18:43.436] List of future strategies:
  [07:18:43.436] 1. sequential:
  [07:18:43.436]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:18:43.436]    - tweaked: FALSE
  [07:18:43.436]    - call: NULL
  [07:18:43.437] plan(): nbrOfWorkers() = 1
  [07:18:43.438] plan(): Setting new future strategy stack:
  [07:18:43.438] List of future strategies:
  [07:18:43.438] 1. sequential:
  [07:18:43.438]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:18:43.438]    - tweaked: FALSE
  [07:18:43.438]    - call: plan(strategy, substitute = FALSE)
  [07:18:43.439] plan(): nbrOfWorkers() = 1
  [07:18:43.439] 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: 0x4744938>
  Arguments '...' exists: TRUE
  [07:18:43.441] getGlobalsAndPackages() ...
  [07:18:43.441] Searching for globals...
  [07:18:43.443] - globals found: [4] '{', 'sum', 'x', '...'
  [07:18:43.444] Searching for globals ... DONE
  [07:18:43.444] Resolving globals: FALSE
  [07:18:43.444] Tweak future expression to call with '...' arguments ...
  [07:18:43.445] Tweak future expression to call with '...' arguments ... DONE
  [07:18:43.445] The total size of the 2 globals is 112 bytes (112 bytes)
  [07:18:43.446] - globals: [2] 'x', 'future.call.arguments'
  [07:18:43.446] 
  [07:18:43.446] getGlobalsAndPackages() ... DONE
  [07:18:43.448] Packages needed by the future expression (n = 0): <none>
  [07:18:43.448] Packages needed by future strategies (n = 0): <none>
  [07:18:43.451] {
  [07:18:43.451]     {
  [07:18:43.451]         ...future.startTime <- base::Sys.time()
  [07:18:43.451]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:18:43.451]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:18:43.451]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:18:43.451]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:18:43.451]             future.resolve.recursive = NULL, width = 80L)
  [07:18:43.451]         {
  [07:18:43.451]             {
  [07:18:43.451]                 base::local({
  [07:18:43.451]                   has_future <- base::requireNamespace("future", 
  [07:18:43.451]                     quietly = TRUE)
  [07:18:43.451]                   version <- if (has_future) 
  [07:18:43.451]                     utils::packageVersion("future")
  [07:18:43.451]                   else NULL
  [07:18:43.451]                   if (!has_future || version < "1.8.0") {
  [07:18:43.451]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:18:43.451]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:18:43.451]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:18:43.451]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:18:43.451]                         "release", "version")], collapse = " "), 
  [07:18:43.451]                       hostname = base::Sys.info()[["nodename"]])
  [07:18:43.451]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:18:43.451]                       info)
  [07:18:43.451]                     info <- base::paste(info, collapse = "; ")
  [07:18:43.451]                     if (!has_future) {
  [07:18:43.451]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:18:43.451]                         info)
  [07:18:43.451]                     }
  [07:18:43.451]                     else {
  [07:18:43.451]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:18:43.451]                         info, version)
  [07:18:43.451]                     }
  [07:18:43.451]                     base::stop(msg)
  [07:18:43.451]                   }
  [07:18:43.451]                 })
  [07:18:43.451]             }
  [07:18:43.451]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:18:43.451]         }
  [07:18:43.451]     }
  [07:18:43.451]     if (base::is.na(TRUE)) {
  [07:18:43.451]     }
  [07:18:43.451]     else {
  [07:18:43.451]         if (TRUE) {
  [07:18:43.451]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:18:43.451]                 open = "w")
  [07:18:43.451]         }
  [07:18:43.451]         else {
  [07:18:43.451]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:18:43.451]                 windows = "NUL", "/dev/null"), open = "w")
  [07:18:43.451]         }
  [07:18:43.451]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:18:43.451]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:18:43.451]             base::sink(type = "output", split = FALSE)
  [07:18:43.451]             base::close(...future.stdout)
  [07:18:43.451]         }, add = TRUE)
  [07:18:43.451]     }
  [07:18:43.451]     ...future.frame <- base::sys.nframe()
  [07:18:43.451]     ...future.conditions <- base::list()
  [07:18:43.451]     ...future.rng <- base::globalenv()$.Random.seed
  [07:18:43.451]     ...future.result <- base::tryCatch({
  [07:18:43.451]         base::withCallingHandlers({
  [07:18:43.451]             ...future.value <- base::withVisible(base::local({
  [07:18:43.451]                 sum(x, ...)
  [07:18:43.451]             }))
  [07:18:43.451]             future::FutureResult(value = ...future.value$value, 
  [07:18:43.451]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:18:43.451]                   ...future.rng), started = ...future.startTime, 
  [07:18:43.451]                 version = "1.8")
  [07:18:43.451]         }, condition = base::local({
  [07:18:43.451]             c <- base::c
  [07:18:43.451]             inherits <- base::inherits
  [07:18:43.451]             invokeRestart <- base::invokeRestart
  [07:18:43.451]             length <- base::length
  [07:18:43.451]             list <- base::list
  [07:18:43.451]             seq.int <- base::seq.int
  [07:18:43.451]             signalCondition <- base::signalCondition
  [07:18:43.451]             sys.calls <- base::sys.calls
  [07:18:43.451]             Sys.time <- base::Sys.time
  [07:18:43.451]             `[[` <- base::`[[`
  [07:18:43.451]             `+` <- base::`+`
  [07:18:43.451]             `<<-` <- base::`<<-`
  [07:18:43.451]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:18:43.451]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:18:43.451]                   3L)]
  [07:18:43.451]             }
  [07:18:43.451]             function(cond) {
  [07:18:43.451]                 if (inherits(cond, "error")) {
  [07:18:43.451]                   sessionInformation <- function() {
  [07:18:43.451]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:18:43.451]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:18:43.451]                       search = base::search(), system = base::Sys.info())
  [07:18:43.451]                   }
  [07:18:43.451]                   ...future.conditions[[length(...future.conditions) + 
  [07:18:43.451]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:18:43.451]                     cond$call), session = sessionInformation(), 
  [07:18:43.451]                     timestamp = Sys.time(), signaled = 0L)
  [07:18:43.451]                   signalCondition(cond)
  [07:18:43.451]                 }
  [07:18:43.451]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:18:43.451]                 ))) {
  [07:18:43.451]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:18:43.451]                   ...future.conditions[[length(...future.conditions) + 
  [07:18:43.451]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:18:43.451]                   if (!signal) {
  [07:18:43.451]                     muffleCondition <- function (cond) 
  [07:18:43.451]                     {
  [07:18:43.451]                       inherits <- base::inherits
  [07:18:43.451]                       invokeRestart <- base::invokeRestart
  [07:18:43.451]                       muffled <- FALSE
  [07:18:43.451]                       if (inherits(cond, "message")) {
  [07:18:43.451]                         invokeRestart("muffleMessage")
  [07:18:43.451]                         muffled <- TRUE
  [07:18:43.451]                       }
  [07:18:43.451]                       else if (inherits(cond, "warning")) {
  [07:18:43.451]                         invokeRestart("muffleWarning")
  [07:18:43.451]                         muffled <- TRUE
  [07:18:43.451]                       }
  [07:18:43.451]                       else if (inherits(cond, "condition")) {
  [07:18:43.451]                         computeRestarts <- base::computeRestarts
  [07:18:43.451]                         grepl <- base::grepl
  [07:18:43.451]                         is.null <- base::is.null
  [07:18:43.451]                         restarts <- computeRestarts(cond)
  [07:18:43.451]                         for (restart in restarts) {
  [07:18:43.451]                           name <- restart$name
  [07:18:43.451]                           if (is.null(name)) 
  [07:18:43.451]                             next
  [07:18:43.451]                           if (!grepl("^muffle", name)) 
  [07:18:43.451]                             next
  [07:18:43.451]                           invokeRestart(restart)
  [07:18:43.451]                           muffled <- TRUE
  [07:18:43.451]                           break
  [07:18:43.451]                         }
  [07:18:43.451]                       }
  [07:18:43.451]                       invisible(muffled)
  [07:18:43.451]                     }
  [07:18:43.451]                     muffleCondition(cond)
  [07:18:43.451]                   }
  [07:18:43.451]                 }
  [07:18:43.451]             }
  [07:18:43.451]         }))
  [07:18:43.451]     }, error = function(ex) {
  [07:18:43.451]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:18:43.451]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:18:43.451]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:18:43.451]     }, finally = {
  [07:18:43.451]         {
  [07:18:43.451]             NULL
  [07:18:43.451]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:18:43.451]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:18:43.451]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:18:43.451]                 label = NULL, ...) 
  [07:18:43.451]             {
  [07:18:43.451]                 if (substitute) 
  [07:18:43.451]                   expr <- substitute(expr)
  [07:18:43.451]                 local <- as.logical(local)
  [07:18:43.451]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:18:43.451]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:18:43.451]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:18:43.451]                   label = label, ...)
  [07:18:43.451]                 if (!future$lazy) 
  [07:18:43.451]                   future <- run(future)
  [07:18:43.451]                 invisible(future)
  [07:18:43.451]             }), .cleanup = FALSE, .init = FALSE)
  [07:18:43.451]         }
  [07:18:43.451]         base::options(...future.oldOptions)
  [07:18:43.451]     })
  [07:18:43.451]     Sys.time
  [07:18:43.451]     if (base::is.na(TRUE)) {
  [07:18:43.451]     }
  [07:18:43.451]     else {
  [07:18:43.451]         base::sink(type = "output", split = FALSE)
  [07:18:43.451]         if (TRUE) {
  [07:18:43.451]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:18:43.451]         }
  [07:18:43.451]         else {
  [07:18:43.451]             ...future.result["stdout"] <- base::list(NULL)
  [07:18:43.451]         }
  [07:18:43.451]         base::close(...future.stdout)
  [07:18:43.451]         ...future.stdout <- NULL
  [07:18:43.451]     }
  [07:18:43.451]     ...future.result$conditions <- ...future.conditions
  [07:18:43.451]     ...future.result
  [07:18:43.451] }
  [07:18:43.454] plan(): Setting new future strategy stack:
  [07:18:43.455] List of future strategies:
  [07:18:43.455] 1. sequential:
  [07:18:43.455]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:18:43.455]    - tweaked: FALSE
  [07:18:43.455]    - call: NULL
  [07:18:43.455] plan(): nbrOfWorkers() = 1
  [07:18:43.456] plan(): Setting new future strategy stack:
  [07:18:43.457] List of future strategies:
  [07:18:43.457] 1. sequential:
  [07:18:43.457]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:18:43.457]    - tweaked: FALSE
  [07:18:43.457]    - call: plan(strategy, substitute = FALSE)
  [07:18:43.457] plan(): nbrOfWorkers() = 1
  [07:18:43.458] 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: 0x31b97e8>
  Arguments '...' exists: FALSE
  [07:18:43.459] getGlobalsAndPackages() ...
  [07:18:43.459] Searching for globals...
  [07:18:43.461] - globals found: [4] '{', 'sum', 'x', 'y'
  [07:18:43.461] Searching for globals ... DONE
  [07:18:43.461] Resolving globals: FALSE
  [07:18:43.462] The total size of the 2 globals is 112 bytes (112 bytes)
  [07:18:43.462] - globals: [2] 'x', 'y'
  [07:18:43.463] 
  [07:18:43.463] getGlobalsAndPackages() ... DONE
  [07:18:43.464] Packages needed by the future expression (n = 0): <none>
  [07:18:43.465] Packages needed by future strategies (n = 0): <none>
  [07:18:43.468] {
  [07:18:43.468]     {
  [07:18:43.468]         ...future.startTime <- base::Sys.time()
  [07:18:43.468]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:18:43.468]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:18:43.468]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:18:43.468]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:18:43.468]             future.resolve.recursive = NULL, width = 80L)
  [07:18:43.468]         {
  [07:18:43.468]             {
  [07:18:43.468]                 base::local({
  [07:18:43.468]                   has_future <- base::requireNamespace("future", 
  [07:18:43.468]                     quietly = TRUE)
  [07:18:43.468]                   version <- if (has_future) 
  [07:18:43.468]                     utils::packageVersion("future")
  [07:18:43.468]                   else NULL
  [07:18:43.468]                   if (!has_future || version < "1.8.0") {
  [07:18:43.468]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:18:43.468]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:18:43.468]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:18:43.468]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:18:43.468]                         "release", "version")], collapse = " "), 
  [07:18:43.468]                       hostname = base::Sys.info()[["nodename"]])
  [07:18:43.468]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:18:43.468]                       info)
  [07:18:43.468]                     info <- base::paste(info, collapse = "; ")
  [07:18:43.468]                     if (!has_future) {
  [07:18:43.468]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:18:43.468]                         info)
  [07:18:43.468]                     }
  [07:18:43.468]                     else {
  [07:18:43.468]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:18:43.468]                         info, version)
  [07:18:43.468]                     }
  [07:18:43.468]                     base::stop(msg)
  [07:18:43.468]                   }
  [07:18:43.468]                 })
  [07:18:43.468]             }
  [07:18:43.468]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:18:43.468]         }
  [07:18:43.468]     }
  [07:18:43.468]     if (base::is.na(TRUE)) {
  [07:18:43.468]     }
  [07:18:43.468]     else {
  [07:18:43.468]         if (TRUE) {
  [07:18:43.468]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:18:43.468]                 open = "w")
  [07:18:43.468]         }
  [07:18:43.468]         else {
  [07:18:43.468]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:18:43.468]                 windows = "NUL", "/dev/null"), open = "w")
  [07:18:43.468]         }
  [07:18:43.468]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:18:43.468]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:18:43.468]             base::sink(type = "output", split = FALSE)
  [07:18:43.468]             base::close(...future.stdout)
  [07:18:43.468]         }, add = TRUE)
  [07:18:43.468]     }
  [07:18:43.468]     ...future.frame <- base::sys.nframe()
  [07:18:43.468]     ...future.conditions <- base::list()
  [07:18:43.468]     ...future.rng <- base::globalenv()$.Random.seed
  [07:18:43.468]     ...future.result <- base::tryCatch({
  [07:18:43.468]         base::withCallingHandlers({
  [07:18:43.468]             ...future.value <- base::withVisible(base::local({
  [07:18:43.468]                 sum(x, y)
  [07:18:43.468]             }))
  [07:18:43.468]             future::FutureResult(value = ...future.value$value, 
  [07:18:43.468]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:18:43.468]                   ...future.rng), started = ...future.startTime, 
  [07:18:43.468]                 version = "1.8")
  [07:18:43.468]         }, condition = base::local({
  [07:18:43.468]             c <- base::c
  [07:18:43.468]             inherits <- base::inherits
  [07:18:43.468]             invokeRestart <- base::invokeRestart
  [07:18:43.468]             length <- base::length
  [07:18:43.468]             list <- base::list
  [07:18:43.468]             seq.int <- base::seq.int
  [07:18:43.468]             signalCondition <- base::signalCondition
  [07:18:43.468]             sys.calls <- base::sys.calls
  [07:18:43.468]             Sys.time <- base::Sys.time
  [07:18:43.468]             `[[` <- base::`[[`
  [07:18:43.468]             `+` <- base::`+`
  [07:18:43.468]             `<<-` <- base::`<<-`
  [07:18:43.468]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:18:43.468]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:18:43.468]                   3L)]
  [07:18:43.468]             }
  [07:18:43.468]             function(cond) {
  [07:18:43.468]                 if (inherits(cond, "error")) {
  [07:18:43.468]                   sessionInformation <- function() {
  [07:18:43.468]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:18:43.468]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:18:43.468]                       search = base::search(), system = base::Sys.info())
  [07:18:43.468]                   }
  [07:18:43.468]                   ...future.conditions[[length(...future.conditions) + 
  [07:18:43.468]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:18:43.468]                     cond$call), session = sessionInformation(), 
  [07:18:43.468]                     timestamp = Sys.time(), signaled = 0L)
  [07:18:43.468]                   signalCondition(cond)
  [07:18:43.468]                 }
  [07:18:43.468]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:18:43.468]                 ))) {
  [07:18:43.468]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:18:43.468]                   ...future.conditions[[length(...future.conditions) + 
  [07:18:43.468]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:18:43.468]                   if (!signal) {
  [07:18:43.468]                     muffleCondition <- function (cond) 
  [07:18:43.468]                     {
  [07:18:43.468]                       inherits <- base::inherits
  [07:18:43.468]                       invokeRestart <- base::invokeRestart
  [07:18:43.468]                       muffled <- FALSE
  [07:18:43.468]                       if (inherits(cond, "message")) {
  [07:18:43.468]                         invokeRestart("muffleMessage")
  [07:18:43.468]                         muffled <- TRUE
  [07:18:43.468]                       }
  [07:18:43.468]                       else if (inherits(cond, "warning")) {
  [07:18:43.468]                         invokeRestart("muffleWarning")
  [07:18:43.468]                         muffled <- TRUE
  [07:18:43.468]                       }
  [07:18:43.468]                       else if (inherits(cond, "condition")) {
  [07:18:43.468]                         computeRestarts <- base::computeRestarts
  [07:18:43.468]                         grepl <- base::grepl
  [07:18:43.468]                         is.null <- base::is.null
  [07:18:43.468]                         restarts <- computeRestarts(cond)
  [07:18:43.468]                         for (restart in restarts) {
  [07:18:43.468]                           name <- restart$name
  [07:18:43.468]                           if (is.null(name)) 
  [07:18:43.468]                             next
  [07:18:43.468]                           if (!grepl("^muffle", name)) 
  [07:18:43.468]                             next
  [07:18:43.468]                           invokeRestart(restart)
  [07:18:43.468]                           muffled <- TRUE
  [07:18:43.468]                           break
  [07:18:43.468]                         }
  [07:18:43.468]                       }
  [07:18:43.468]                       invisible(muffled)
  [07:18:43.468]                     }
  [07:18:43.468]                     muffleCondition(cond)
  [07:18:43.468]                   }
  [07:18:43.468]                 }
  [07:18:43.468]             }
  [07:18:43.468]         }))
  [07:18:43.468]     }, error = function(ex) {
  [07:18:43.468]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:18:43.468]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:18:43.468]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:18:43.468]     }, finally = {
  [07:18:43.468]         {
  [07:18:43.468]             NULL
  [07:18:43.468]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:18:43.468]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:18:43.468]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:18:43.468]                 label = NULL, ...) 
  [07:18:43.468]             {
  [07:18:43.468]                 if (substitute) 
  [07:18:43.468]                   expr <- substitute(expr)
  [07:18:43.468]                 local <- as.logical(local)
  [07:18:43.468]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:18:43.468]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:18:43.468]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:18:43.468]                   label = label, ...)
  [07:18:43.468]                 if (!future$lazy) 
  [07:18:43.468]                   future <- run(future)
  [07:18:43.468]                 invisible(future)
  [07:18:43.468]             }), .cleanup = FALSE, .init = FALSE)
  [07:18:43.468]         }
  [07:18:43.468]         base::options(...future.oldOptions)
  [07:18:43.468]     })
  [07:18:43.468]     Sys.time
  [07:18:43.468]     if (base::is.na(TRUE)) {
  [07:18:43.468]     }
  [07:18:43.468]     else {
  [07:18:43.468]         base::sink(type = "output", split = FALSE)
  [07:18:43.468]         if (TRUE) {
  [07:18:43.468]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:18:43.468]         }
  [07:18:43.468]         else {
  [07:18:43.468]             ...future.result["stdout"] <- base::list(NULL)
  [07:18:43.468]         }
  [07:18:43.468]         base::close(...future.stdout)
  [07:18:43.468]         ...future.stdout <- NULL
  [07:18:43.468]     }
  [07:18:43.468]     ...future.result$conditions <- ...future.conditions
  [07:18:43.468]     ...future.result
  [07:18:43.468] }
  [07:18:43.471] plan(): Setting new future strategy stack:
  [07:18:43.471] List of future strategies:
  [07:18:43.471] 1. sequential:
  [07:18:43.471]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:18:43.471]    - tweaked: FALSE
  [07:18:43.471]    - call: NULL
  [07:18:43.472] plan(): nbrOfWorkers() = 1
  [07:18:43.473] plan(): Setting new future strategy stack:
  [07:18:43.473] List of future strategies:
  [07:18:43.473] 1. sequential:
  [07:18:43.473]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:18:43.473]    - tweaked: FALSE
  [07:18:43.473]    - call: plan(strategy, substitute = FALSE)
  [07:18:43.474] plan(): nbrOfWorkers() = 1
  [07:18:43.474] 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: 0x28cb660>
  Arguments '...' exists: FALSE
  [07:18:43.475] getGlobalsAndPackages() ...
  [07:18:43.476] Searching for globals...
  [07:18:43.478] - globals found: [5] '{', 'sum', 'x', 'y', '...'
  [07:18:43.478] Searching for globals ... DONE
  [07:18:43.478] Resolving globals: FALSE
  [07:18:43.479] Tweak future expression to call with '...' arguments ...
  [07:18:43.479] 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:18:43.489] plan(): Setting new future strategy stack:
  [07:18:43.490] List of future strategies:
  [07:18:43.490] 1. multicore:
  [07:18:43.490]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:18:43.490]    - tweaked: FALSE
  [07:18:43.490]    - call: plan(strategy, substitute = FALSE)
  [07:18:43.491] plan(): nbrOfWorkers() = 2
  ** Sum function 'A' with plan('multicore') ...
  function (x, ...) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, ...)
      }
      y
  }
  <bytecode: 0x42964a8>
  Arguments '...' exists: TRUE
  [07:18:43.492] getGlobalsAndPackages() ...
  [07:18:43.492] Searching for globals...
  [07:18:43.494] - globals found: [4] '{', 'sum', 'x', '...'
  [07:18:43.495] Searching for globals ... DONE
  [07:18:43.495] Resolving globals: FALSE
  [07:18:43.495] Tweak future expression to call with '...' arguments ...
  [07:18:43.496] Tweak future expression to call with '...' arguments ... DONE
  [07:18:43.496] The total size of the 2 globals is 112 bytes (112 bytes)
  [07:18:43.497] - globals: [2] 'x', 'future.call.arguments'
  [07:18:43.497] 
  [07:18:43.497] getGlobalsAndPackages() ... DONE
  [07:18:43.499] Packages needed by the future expression (n = 0): <none>
  [07:18:43.499] Packages needed by future strategies (n = 0): <none>
  [07:18:43.502] {
  [07:18:43.502]     {
  [07:18:43.502]         ...future.startTime <- base::Sys.time()
  [07:18:43.502]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:18:43.502]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:18:43.502]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:18:43.502]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:18:43.502]             future.resolve.recursive = NULL, width = 80L)
  [07:18:43.502]         {
  [07:18:43.502]             {
  [07:18:43.502]                 {
  [07:18:43.502]                   base::local({
  [07:18:43.502]                     has_future <- base::requireNamespace("future", 
  [07:18:43.502]                       quietly = TRUE)
  [07:18:43.502]                     version <- if (has_future) 
  [07:18:43.502]                       utils::packageVersion("future")
  [07:18:43.502]                     else NULL
  [07:18:43.502]                     if (!has_future || version < "1.8.0") {
  [07:18:43.502]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:18:43.502]                         "", base::R.version$version.string), 
  [07:18:43.502]                         platform = base::sprintf("%s (%s-bit)", 
  [07:18:43.502]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:18:43.502]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:18:43.502]                           "release", "version")], collapse = " "), 
  [07:18:43.502]                         hostname = base::Sys.info()[["nodename"]])
  [07:18:43.502]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:18:43.502]                         info)
  [07:18:43.502]                       info <- base::paste(info, collapse = "; ")
  [07:18:43.502]                       if (!has_future) {
  [07:18:43.502]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:18:43.502]                           info)
  [07:18:43.502]                       }
  [07:18:43.502]                       else {
  [07:18:43.502]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:18:43.502]                           info, version)
  [07:18:43.502]                       }
  [07:18:43.502]                       base::stop(msg)
  [07:18:43.502]                     }
  [07:18:43.502]                   })
  [07:18:43.502]                 }
  [07:18:43.502]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:18:43.502]                 base::options(mc.cores = 1L)
  [07:18:43.502]             }
  [07:18:43.502]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:18:43.502]         }
  [07:18:43.502]     }
  [07:18:43.502]     if (base::is.na(TRUE)) {
  [07:18:43.502]     }
  [07:18:43.502]     else {
  [07:18:43.502]         if (TRUE) {
  [07:18:43.502]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:18:43.502]                 open = "w")
  [07:18:43.502]         }
  [07:18:43.502]         else {
  [07:18:43.502]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:18:43.502]                 windows = "NUL", "/dev/null"), open = "w")
  [07:18:43.502]         }
  [07:18:43.502]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:18:43.502]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:18:43.502]             base::sink(type = "output", split = FALSE)
  [07:18:43.502]             base::close(...future.stdout)
  [07:18:43.502]         }, add = TRUE)
  [07:18:43.502]     }
  [07:18:43.502]     ...future.frame <- base::sys.nframe()
  [07:18:43.502]     ...future.conditions <- base::list()
  [07:18:43.502]     ...future.rng <- base::globalenv()$.Random.seed
  [07:18:43.502]     ...future.result <- base::tryCatch({
  [07:18:43.502]         base::withCallingHandlers({
  [07:18:43.502]             ...future.value <- base::withVisible(base::local({
  [07:18:43.502]                 sum(x, ...)
  [07:18:43.502]             }))
  [07:18:43.502]             future::FutureResult(value = ...future.value$value, 
  [07:18:43.502]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:18:43.502]                   ...future.rng), started = ...future.startTime, 
  [07:18:43.502]                 version = "1.8")
  [07:18:43.502]         }, condition = base::local({
  [07:18:43.502]             c <- base::c
  [07:18:43.502]             inherits <- base::inherits
  [07:18:43.502]             invokeRestart <- base::invokeRestart
  [07:18:43.502]             length <- base::length
  [07:18:43.502]             list <- base::list
  [07:18:43.502]             seq.int <- base::seq.int
  [07:18:43.502]             signalCondition <- base::signalCondition
  [07:18:43.502]             sys.calls <- base::sys.calls
  [07:18:43.502]             Sys.time <- base::Sys.time
  [07:18:43.502]             `[[` <- base::`[[`
  [07:18:43.502]             `+` <- base::`+`
  [07:18:43.502]             `<<-` <- base::`<<-`
  [07:18:43.502]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:18:43.502]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:18:43.502]                   3L)]
  [07:18:43.502]             }
  [07:18:43.502]             function(cond) {
  [07:18:43.502]                 if (inherits(cond, "error")) {
  [07:18:43.502]                   sessionInformation <- function() {
  [07:18:43.502]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:18:43.502]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:18:43.502]                       search = base::search(), system = base::Sys.info())
  [07:18:43.502]                   }
  [07:18:43.502]                   ...future.conditions[[length(...future.conditions) + 
  [07:18:43.502]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:18:43.502]                     cond$call), session = sessionInformation(), 
  [07:18:43.502]                     timestamp = Sys.time(), signaled = 0L)
  [07:18:43.502]                   signalCondition(cond)
  [07:18:43.502]                 }
  [07:18:43.502]                 else if (inherits(cond, "condition")) {
  [07:18:43.502]                   signal <- FALSE && inherits(cond, character(0))
  [07:18:43.502]                   ...future.conditions[[length(...future.conditions) + 
  [07:18:43.502]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:18:43.502]                   if (!signal) {
  [07:18:43.502]                     muffleCondition <- function (cond) 
  [07:18:43.502]                     {
  [07:18:43.502]                       inherits <- base::inherits
  [07:18:43.502]                       invokeRestart <- base::invokeRestart
  [07:18:43.502]                       muffled <- FALSE
  [07:18:43.502]                       if (inherits(cond, "message")) {
  [07:18:43.502]                         invokeRestart("muffleMessage")
  [07:18:43.502]                         muffled <- TRUE
  [07:18:43.502]                       }
  [07:18:43.502]                       else if (inherits(cond, "warning")) {
  [07:18:43.502]                         invokeRestart("muffleWarning")
  [07:18:43.502]                         muffled <- TRUE
  [07:18:43.502]                       }
  [07:18:43.502]                       else if (inherits(cond, "condition")) {
  [07:18:43.502]                         computeRestarts <- base::computeRestarts
  [07:18:43.502]                         grepl <- base::grepl
  [07:18:43.502]                         is.null <- base::is.null
  [07:18:43.502]                         restarts <- computeRestarts(cond)
  [07:18:43.502]                         for (restart in restarts) {
  [07:18:43.502]                           name <- restart$name
  [07:18:43.502]                           if (is.null(name)) 
  [07:18:43.502]                             next
  [07:18:43.502]                           if (!grepl("^muffle", name)) 
  [07:18:43.502]                             next
  [07:18:43.502]                           invokeRestart(restart)
  [07:18:43.502]                           muffled <- TRUE
  [07:18:43.502]                           break
  [07:18:43.502]                         }
  [07:18:43.502]                       }
  [07:18:43.502]                       invisible(muffled)
  [07:18:43.502]                     }
  [07:18:43.502]                     muffleCondition(cond)
  [07:18:43.502]                   }
  [07:18:43.502]                 }
  [07:18:43.502]             }
  [07:18:43.502]         }))
  [07:18:43.502]     }, error = function(ex) {
  [07:18:43.502]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:18:43.502]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:18:43.502]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:18:43.502]     }, finally = {
  [07:18:43.502]         {
  [07:18:43.502]             {
  [07:18:43.502]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:18:43.502]             }
  [07:18:43.502]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:18:43.502]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:18:43.502]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:18:43.502]                 earlySignal = FALSE, label = NULL, ...) 
  [07:18:43.502]             {
  [07:18:43.502]                 if (substitute) 
  [07:18:43.502]                   expr <- substitute(expr)
  [07:18:43.502]                 if (is.function(workers)) 
  [07:18:43.502]                   workers <- workers()
  [07:18:43.502]                 workers <- as.integer(workers)
  [07:18:43.502]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:18:43.502]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:18:43.502]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:18:43.502]                     lazy = lazy, seed = seed, globals = globals, 
  [07:18:43.502]                     local = TRUE, label = label, ...))
  [07:18:43.502]                 }
  [07:18:43.502]                 oopts <- options(mc.cores = workers)
  [07:18:43.502]                 on.exit(options(oopts))
  [07:18:43.502]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:18:43.502]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:18:43.502]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:18:43.502]                   label = label, ...)
  [07:18:43.502]                 if (!future$lazy) 
  [07:18:43.502]                   future <- run(future)
  [07:18:43.502]                 invisible(future)
  [07:18:43.502]             }), .cleanup = FALSE, .init = FALSE)
  [07:18:43.502]         }
  [07:18:43.502]         base::options(...future.oldOptions)
  [07:18:43.502]     })
  [07:18:43.502]     Sys.time
  [07:18:43.502]     if (base::is.na(TRUE)) {
  [07:18:43.502]     }
  [07:18:43.502]     else {
  [07:18:43.502]         base::sink(type = "output", split = FALSE)
  [07:18:43.502]         if (TRUE) {
  [07:18:43.502]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:18:43.502]         }
  [07:18:43.502]         else {
  [07:18:43.502]             ...future.result["stdout"] <- base::list(NULL)
  [07:18:43.502]         }
  [07:18:43.502]         base::close(...future.stdout)
  [07:18:43.502]         ...future.stdout <- NULL
  [07:18:43.502]     }
  [07:18:43.502]     ...future.result$conditions <- ...future.conditions
  [07:18:43.502]     ...future.result
  [07:18:43.502] }
  [07:18:43.505] requestCore(): workers = 2
  [07:18:43.509] MulticoreFuture started
  [07:18:43.512] plan(): Setting new future strategy stack:
  [07:18:43.513] List of future strategies:
  [07:18:43.513] 1. sequential:
  [07:18:43.513]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:18:43.513]    - tweaked: FALSE
  [07:18:43.513]    - call: NULL
  [07:18:43.514] plan(): nbrOfWorkers() = 1
  [07:18:43.516] plan(): Setting new future strategy stack:
  [07:18:43.517] List of future strategies:
  [07:18:43.517] 1. multicore:
  [07:18:43.517]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:18:43.517]    - tweaked: FALSE
  [07:18:43.517]    - call: plan(strategy, substitute = FALSE)
  [07:18:43.519] 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: 0x4744938>
  Arguments '...' exists: TRUE
  [07:18:43.528] getGlobalsAndPackages() ...
  [07:18:43.529] Searching for globals...
  [07:18:43.532] - globals found: [4] '{', 'sum', 'x', '...'
  [07:18:43.532] Searching for globals ... DONE
  [07:18:43.533] Resolving globals: FALSE
  [07:18:43.533] Tweak future expression to call with '...' arguments ...
  [07:18:43.534] Tweak future expression to call with '...' arguments ... DONE
  [07:18:43.535] The total size of the 2 globals is 112 bytes (112 bytes)
  [07:18:43.535] - globals: [2] 'x', 'future.call.arguments'
  [07:18:43.536] 
  [07:18:43.536] getGlobalsAndPackages() ... DONE
  [07:18:43.538] Packages needed by the future expression (n = 0): <none>
  [07:18:43.538] Packages needed by future strategies (n = 0): <none>
  [07:18:43.542] {
  [07:18:43.542]     {
  [07:18:43.542]         ...future.startTime <- base::Sys.time()
  [07:18:43.542]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:18:43.542]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:18:43.542]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:18:43.542]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:18:43.542]             future.resolve.recursive = NULL, width = 80L)
  [07:18:43.542]         {
  [07:18:43.542]             {
  [07:18:43.542]                 {
  [07:18:43.542]                   base::local({
  [07:18:43.542]                     has_future <- base::requireNamespace("future", 
  [07:18:43.542]                       quietly = TRUE)
  [07:18:43.542]                     version <- if (has_future) 
  [07:18:43.542]                       utils::packageVersion("future")
  [07:18:43.542]                     else NULL
  [07:18:43.542]                     if (!has_future || version < "1.8.0") {
  [07:18:43.542]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:18:43.542]                         "", base::R.version$version.string), 
  [07:18:43.542]                         platform = base::sprintf("%s (%s-bit)", 
  [07:18:43.542]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:18:43.542]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:18:43.542]                           "release", "version")], collapse = " "), 
  [07:18:43.542]                         hostname = base::Sys.info()[["nodename"]])
  [07:18:43.542]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:18:43.542]                         info)
  [07:18:43.542]                       info <- base::paste(info, collapse = "; ")
  [07:18:43.542]                       if (!has_future) {
  [07:18:43.542]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:18:43.542]                           info)
  [07:18:43.542]                       }
  [07:18:43.542]                       else {
  [07:18:43.542]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:18:43.542]                           info, version)
  [07:18:43.542]                       }
  [07:18:43.542]                       base::stop(msg)
  [07:18:43.542]                     }
  [07:18:43.542]                   })
  [07:18:43.542]                 }
  [07:18:43.542]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:18:43.542]                 base::options(mc.cores = 1L)
  [07:18:43.542]             }
  [07:18:43.542]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:18:43.542]         }
  [07:18:43.542]     }
  [07:18:43.542]     if (base::is.na(TRUE)) {
  [07:18:43.542]     }
  [07:18:43.542]     else {
  [07:18:43.542]         if (TRUE) {
  [07:18:43.542]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:18:43.542]                 open = "w")
  [07:18:43.542]         }
  [07:18:43.542]         else {
  [07:18:43.542]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:18:43.542]                 windows = "NUL", "/dev/null"), open = "w")
  [07:18:43.542]         }
  [07:18:43.542]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:18:43.542]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:18:43.542]             base::sink(type = "output", split = FALSE)
  [07:18:43.542]             base::close(...future.stdout)
  [07:18:43.542]         }, add = TRUE)
  [07:18:43.542]     }
  [07:18:43.542]     ...future.frame <- base::sys.nframe()
  [07:18:43.542]     ...future.conditions <- base::list()
  [07:18:43.542]     ...future.rng <- base::globalenv()$.Random.seed
  [07:18:43.542]     ...future.result <- base::tryCatch({
  [07:18:43.542]         base::withCallingHandlers({
  [07:18:43.542]             ...future.value <- base::withVisible(base::local({
  [07:18:43.542]                 sum(x, ...)
  [07:18:43.542]             }))
  [07:18:43.542]             future::FutureResult(value = ...future.value$value, 
  [07:18:43.542]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:18:43.542]                   ...future.rng), started = ...future.startTime, 
  [07:18:43.542]                 version = "1.8")
  [07:18:43.542]         }, condition = base::local({
  [07:18:43.542]             c <- base::c
  [07:18:43.542]             inherits <- base::inherits
  [07:18:43.542]             invokeRestart <- base::invokeRestart
  [07:18:43.542]             length <- base::length
  [07:18:43.542]             list <- base::list
  [07:18:43.542]             seq.int <- base::seq.int
  [07:18:43.542]             signalCondition <- base::signalCondition
  [07:18:43.542]             sys.calls <- base::sys.calls
  [07:18:43.542]             Sys.time <- base::Sys.time
  [07:18:43.542]             `[[` <- base::`[[`
  [07:18:43.542]             `+` <- base::`+`
  [07:18:43.542]             `<<-` <- base::`<<-`
  [07:18:43.542]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:18:43.542]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:18:43.542]                   3L)]
  [07:18:43.542]             }
  [07:18:43.542]             function(cond) {
  [07:18:43.542]                 if (inherits(cond, "error")) {
  [07:18:43.542]                   sessionInformation <- function() {
  [07:18:43.542]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:18:43.542]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:18:43.542]                       search = base::search(), system = base::Sys.info())
  [07:18:43.542]                   }
  [07:18:43.542]                   ...future.conditions[[length(...future.conditions) + 
  [07:18:43.542]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:18:43.542]                     cond$call), session = sessionInformation(), 
  [07:18:43.542]                     timestamp = Sys.time(), signaled = 0L)
  [07:18:43.542]                   signalCondition(cond)
  [07:18:43.542]                 }
  [07:18:43.542]                 else if (inherits(cond, "condition")) {
  [07:18:43.542]                   signal <- FALSE && inherits(cond, character(0))
  [07:18:43.542]                   ...future.conditions[[length(...future.conditions) + 
  [07:18:43.542]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:18:43.542]                   if (!signal) {
  [07:18:43.542]                     muffleCondition <- function (cond) 
  [07:18:43.542]                     {
  [07:18:43.542]                       inherits <- base::inherits
  [07:18:43.542]                       invokeRestart <- base::invokeRestart
  [07:18:43.542]                       muffled <- FALSE
  [07:18:43.542]                       if (inherits(cond, "message")) {
  [07:18:43.542]                         invokeRestart("muffleMessage")
  [07:18:43.542]                         muffled <- TRUE
  [07:18:43.542]                       }
  [07:18:43.542]                       else if (inherits(cond, "warning")) {
  [07:18:43.542]                         invokeRestart("muffleWarning")
  [07:18:43.542]                         muffled <- TRUE
  [07:18:43.542]                       }
  [07:18:43.542]                       else if (inherits(cond, "condition")) {
  [07:18:43.542]                         computeRestarts <- base::computeRestarts
  [07:18:43.542]                         grepl <- base::grepl
  [07:18:43.542]                         is.null <- base::is.null
  [07:18:43.542]                         restarts <- computeRestarts(cond)
  [07:18:43.542]                         for (restart in restarts) {
  [07:18:43.542]                           name <- restart$name
  [07:18:43.542]                           if (is.null(name)) 
  [07:18:43.542]                             next
  [07:18:43.542]                           if (!grepl("^muffle", name)) 
  [07:18:43.542]                             next
  [07:18:43.542]                           invokeRestart(restart)
  [07:18:43.542]                           muffled <- TRUE
  [07:18:43.542]                           break
  [07:18:43.542]                         }
  [07:18:43.542]                       }
  [07:18:43.542]                       invisible(muffled)
  [07:18:43.542]                     }
  [07:18:43.542]                     muffleCondition(cond)
  [07:18:43.542]                   }
  [07:18:43.542]                 }
  [07:18:43.542]             }
  [07:18:43.542]         }))
  [07:18:43.542]     }, error = function(ex) {
  [07:18:43.542]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:18:43.542]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:18:43.542]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:18:43.542]     }, finally = {
  [07:18:43.542]         {
  [07:18:43.542]             {
  [07:18:43.542]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:18:43.542]             }
  [07:18:43.542]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:18:43.542]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:18:43.542]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:18:43.542]                 earlySignal = FALSE, label = NULL, ...) 
  [07:18:43.542]             {
  [07:18:43.542]                 if (substitute) 
  [07:18:43.542]                   expr <- substitute(expr)
  [07:18:43.542]                 if (is.function(workers)) 
  [07:18:43.542]                   workers <- workers()
  [07:18:43.542]                 workers <- as.integer(workers)
  [07:18:43.542]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:18:43.542]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:18:43.542]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:18:43.542]                     lazy = lazy, seed = seed, globals = globals, 
  [07:18:43.542]                     local = TRUE, label = label, ...))
  [07:18:43.542]                 }
  [07:18:43.542]                 oopts <- options(mc.cores = workers)
  [07:18:43.542]                 on.exit(options(oopts))
  [07:18:43.542]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:18:43.542]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:18:43.542]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:18:43.542]                   label = label, ...)
  [07:18:43.542]                 if (!future$lazy) 
  [07:18:43.542]                   future <- run(future)
  [07:18:43.542]                 invisible(future)
  [07:18:43.542]             }), .cleanup = FALSE, .init = FALSE)
  [07:18:43.542]         }
  [07:18:43.542]         base::options(...future.oldOptions)
  [07:18:43.542]     })
  [07:18:43.542]     Sys.time
  [07:18:43.542]     if (base::is.na(TRUE)) {
  [07:18:43.542]     }
  [07:18:43.542]     else {
  [07:18:43.542]         base::sink(type = "output", split = FALSE)
  [07:18:43.542]         if (TRUE) {
  [07:18:43.542]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:18:43.542]         }
  [07:18:43.542]         else {
  [07:18:43.542]             ...future.result["stdout"] <- base::list(NULL)
  [07:18:43.542]         }
  [07:18:43.542]         base::close(...future.stdout)
  [07:18:43.542]         ...future.stdout <- NULL
  [07:18:43.542]     }
  [07:18:43.542]     ...future.result$conditions <- ...future.conditions
  [07:18:43.542]     ...future.result
  [07:18:43.542] }
  [07:18:43.545] requestCore(): workers = 2
  [07:18:43.547] MulticoreFuture started
  [07:18:43.550] plan(): Setting new future strategy stack:
  [07:18:43.551] List of future strategies:
  [07:18:43.551] 1. sequential:
  [07:18:43.551]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:18:43.551]    - tweaked: FALSE
  [07:18:43.551]    - call: NULL
  [07:18:43.553] plan(): nbrOfWorkers() = 1
  [07:18:43.555] plan(): Setting new future strategy stack:
  [07:18:43.556] List of future strategies:
  [07:18:43.556] 1. multicore:
  [07:18:43.556]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:18:43.556]    - tweaked: FALSE
  [07:18:43.556]    - call: plan(strategy, substitute = FALSE)
  [07:18:43.558] 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: 0x31b97e8>
  Arguments '...' exists: FALSE
  [07:18:43.561] getGlobalsAndPackages() ...
  [07:18:43.562] Searching for globals...
  [07:18:43.565] - globals found: [4] '{', 'sum', 'x', 'y'
  [07:18:43.565] Searching for globals ... DONE
  [07:18:43.566] Resolving globals: FALSE
  [07:18:43.567] The total size of the 2 globals is 112 bytes (112 bytes)
  [07:18:43.567] - globals: [2] 'x', 'y'
  [07:18:43.568] 
  [07:18:43.568] getGlobalsAndPackages() ... DONE
  [07:18:43.571] Packages needed by the future expression (n = 0): <none>
  [07:18:43.571] Packages needed by future strategies (n = 0): <none>
  [07:18:43.575] {
  [07:18:43.575]     {
  [07:18:43.575]         ...future.startTime <- base::Sys.time()
  [07:18:43.575]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:18:43.575]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:18:43.575]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:18:43.575]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:18:43.575]             future.resolve.recursive = NULL, width = 80L)
  [07:18:43.575]         {
  [07:18:43.575]             {
  [07:18:43.575]                 {
  [07:18:43.575]                   base::local({
  [07:18:43.575]                     has_future <- base::requireNamespace("future", 
  [07:18:43.575]                       quietly = TRUE)
  [07:18:43.575]                     version <- if (has_future) 
  [07:18:43.575]                       utils::packageVersion("future")
  [07:18:43.575]                     else NULL
  [07:18:43.575]                     if (!has_future || version < "1.8.0") {
  [07:18:43.575]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:18:43.575]                         "", base::R.version$version.string), 
  [07:18:43.575]                         platform = base::sprintf("%s (%s-bit)", 
  [07:18:43.575]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:18:43.575]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:18:43.575]                           "release", "version")], collapse = " "), 
  [07:18:43.575]                         hostname = base::Sys.info()[["nodename"]])
  [07:18:43.575]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:18:43.575]                         info)
  [07:18:43.575]                       info <- base::paste(info, collapse = "; ")
  [07:18:43.575]                       if (!has_future) {
  [07:18:43.575]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:18:43.575]                           info)
  [07:18:43.575]                       }
  [07:18:43.575]                       else {
  [07:18:43.575]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:18:43.575]                           info, version)
  [07:18:43.575]                       }
  [07:18:43.575]                       base::stop(msg)
  [07:18:43.575]                     }
  [07:18:43.575]                   })
  [07:18:43.575]                 }
  [07:18:43.575]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:18:43.575]                 base::options(mc.cores = 1L)
  [07:18:43.575]             }
  [07:18:43.575]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:18:43.575]         }
  [07:18:43.575]     }
  [07:18:43.575]     if (base::is.na(TRUE)) {
  [07:18:43.575]     }
  [07:18:43.575]     else {
  [07:18:43.575]         if (TRUE) {
  [07:18:43.575]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:18:43.575]                 open = "w")
  [07:18:43.575]         }
  [07:18:43.575]         else {
  [07:18:43.575]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:18:43.575]                 windows = "NUL", "/dev/null"), open = "w")
  [07:18:43.575]         }
  [07:18:43.575]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:18:43.575]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:18:43.575]             base::sink(type = "output", split = FALSE)
  [07:18:43.575]             base::close(...future.stdout)
  [07:18:43.575]         }, add = TRUE)
  [07:18:43.575]     }
  [07:18:43.575]     ...future.frame <- base::sys.nframe()
  [07:18:43.575]     ...future.conditions <- base::list()
  [07:18:43.575]     ...future.rng <- base::globalenv()$.Random.seed
  [07:18:43.575]     ...future.result <- base::tryCatch({
  [07:18:43.575]         base::withCallingHandlers({
  [07:18:43.575]             ...future.value <- base::withVisible(base::local({
  [07:18:43.575]                 sum(x, y)
  [07:18:43.575]             }))
  [07:18:43.575]             future::FutureResult(value = ...future.value$value, 
  [07:18:43.575]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:18:43.575]                   ...future.rng), started = ...future.startTime, 
  [07:18:43.575]                 version = "1.8")
  [07:18:43.575]         }, condition = base::local({
  [07:18:43.575]             c <- base::c
  [07:18:43.575]             inherits <- base::inherits
  [07:18:43.575]             invokeRestart <- base::invokeRestart
  [07:18:43.575]             length <- base::length
  [07:18:43.575]             list <- base::list
  [07:18:43.575]             seq.int <- base::seq.int
  [07:18:43.575]             signalCondition <- base::signalCondition
  [07:18:43.575]             sys.calls <- base::sys.calls
  [07:18:43.575]             Sys.time <- base::Sys.time
  [07:18:43.575]             `[[` <- base::`[[`
  [07:18:43.575]             `+` <- base::`+`
  [07:18:43.575]             `<<-` <- base::`<<-`
  [07:18:43.575]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:18:43.575]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:18:43.575]                   3L)]
  [07:18:43.575]             }
  [07:18:43.575]             function(cond) {
  [07:18:43.575]                 if (inherits(cond, "error")) {
  [07:18:43.575]                   sessionInformation <- function() {
  [07:18:43.575]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:18:43.575]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:18:43.575]                       search = base::search(), system = base::Sys.info())
  [07:18:43.575]                   }
  [07:18:43.575]                   ...future.conditions[[length(...future.conditions) + 
  [07:18:43.575]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:18:43.575]                     cond$call), session = sessionInformation(), 
  [07:18:43.575]                     timestamp = Sys.time(), signaled = 0L)
  [07:18:43.575]                   signalCondition(cond)
  [07:18:43.575]                 }
  [07:18:43.575]                 else if (inherits(cond, "condition")) {
  [07:18:43.575]                   signal <- FALSE && inherits(cond, character(0))
  [07:18:43.575]                   ...future.conditions[[length(...future.conditions) + 
  [07:18:43.575]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:18:43.575]                   if (!signal) {
  [07:18:43.575]                     muffleCondition <- function (cond) 
  [07:18:43.575]                     {
  [07:18:43.575]                       inherits <- base::inherits
  [07:18:43.575]                       invokeRestart <- base::invokeRestart
  [07:18:43.575]                       muffled <- FALSE
  [07:18:43.575]                       if (inherits(cond, "message")) {
  [07:18:43.575]                         invokeRestart("muffleMessage")
  [07:18:43.575]                         muffled <- TRUE
  [07:18:43.575]                       }
  [07:18:43.575]                       else if (inherits(cond, "warning")) {
  [07:18:43.575]                         invokeRestart("muffleWarning")
  [07:18:43.575]                         muffled <- TRUE
  [07:18:43.575]                       }
  [07:18:43.575]                       else if (inherits(cond, "condition")) {
  [07:18:43.575]                         computeRestarts <- base::computeRestarts
  [07:18:43.575]                         grepl <- base::grepl
  [07:18:43.575]                         is.null <- base::is.null
  [07:18:43.575]                         restarts <- computeRestarts(cond)
  [07:18:43.575]                         for (restart in restarts) {
  [07:18:43.575]                           name <- restart$name
  [07:18:43.575]                           if (is.null(name)) 
  [07:18:43.575]                             next
  [07:18:43.575]                           if (!grepl("^muffle", name)) 
  [07:18:43.575]                             next
  [07:18:43.575]                           invokeRestart(restart)
  [07:18:43.575]                           muffled <- TRUE
  [07:18:43.575]                           break
  [07:18:43.575]                         }
  [07:18:43.575]                       }
  [07:18:43.575]                       invisible(muffled)
  [07:18:43.575]                     }
  [07:18:43.575]                     muffleCondition(cond)
  [07:18:43.575]                   }
  [07:18:43.575]                 }
  [07:18:43.575]             }
  [07:18:43.575]         }))
  [07:18:43.575]     }, error = function(ex) {
  [07:18:43.575]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:18:43.575]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:18:43.575]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:18:43.575]     }, finally = {
  [07:18:43.575]         {
  [07:18:43.575]             {
  [07:18:43.575]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:18:43.575]             }
  [07:18:43.575]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:18:43.575]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:18:43.575]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:18:43.575]                 earlySignal = FALSE, label = NULL, ...) 
  [07:18:43.575]             {
  [07:18:43.575]                 if (substitute) 
  [07:18:43.575]                   expr <- substitute(expr)
  [07:18:43.575]                 if (is.function(workers)) 
  [07:18:43.575]                   workers <- workers()
  [07:18:43.575]                 workers <- as.integer(workers)
  [07:18:43.575]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:18:43.575]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:18:43.575]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:18:43.575]                     lazy = lazy, seed = seed, globals = globals, 
  [07:18:43.575]                     local = TRUE, label = label, ...))
  [07:18:43.575]                 }
  [07:18:43.575]                 oopts <- options(mc.cores = workers)
  [07:18:43.575]                 on.exit(options(oopts))
  [07:18:43.575]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:18:43.575]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:18:43.575]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:18:43.575]                   label = label, ...)
  [07:18:43.575]                 if (!future$lazy) 
  [07:18:43.575]                   future <- run(future)
  [07:18:43.575]                 invisible(future)
  [07:18:43.575]             }), .cleanup = FALSE, .init = FALSE)
  [07:18:43.575]         }
  [07:18:43.575]         base::options(...future.oldOptions)
  [07:18:43.575]     })
  [07:18:43.575]     Sys.time
  [07:18:43.575]     if (base::is.na(TRUE)) {
  [07:18:43.575]     }
  [07:18:43.575]     else {
  [07:18:43.575]         base::sink(type = "output", split = FALSE)
  [07:18:43.575]         if (TRUE) {
  [07:18:43.575]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:18:43.575]         }
  [07:18:43.575]         else {
  [07:18:43.575]             ...future.result["stdout"] <- base::list(NULL)
  [07:18:43.575]         }
  [07:18:43.575]         base::close(...future.stdout)
  [07:18:43.575]         ...future.stdout <- NULL
  [07:18:43.575]     }
  [07:18:43.575]     ...future.result$conditions <- ...future.conditions
  [07:18:43.575]     ...future.result
  [07:18:43.575] }
  [07:18:43.578] requestCore(): workers = 2
  [07:18:43.584] MulticoreFuture started
  [07:18:43.589] plan(): Setting new future strategy stack:
  [07:18:43.590] List of future strategies:
  [07:18:43.590] 1. sequential:
  [07:18:43.590]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:18:43.590]    - tweaked: FALSE
  [07:18:43.590]    - call: NULL
  [07:18:43.592] plan(): nbrOfWorkers() = 1
  [07:18:43.595] plan(): Setting new future strategy stack:
  [07:18:43.596] List of future strategies:
  [07:18:43.596] 1. multicore:
  [07:18:43.596]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:18:43.596]    - tweaked: FALSE
  [07:18:43.596]    - call: plan(strategy, substitute = FALSE)
  [07:18:43.598] 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: 0x28cb660>
  Arguments '...' exists: FALSE
  [07:18:43.601] getGlobalsAndPackages() ...
  [07:18:43.602] Searching for globals...
  [07:18:43.606] - globals found: [5] '{', 'sum', 'x', 'y', '...'
  [07:18:43.606] Searching for globals ... DONE
  [07:18:43.607] Resolving globals: FALSE
  [07:18:43.607] Tweak future expression to call with '...' arguments ...
  [07:18:43.608] 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:18:43.610] plan(): Setting new future strategy stack:
  [07:18:43.610] List of future strategies:
  [07:18:43.610] 1. multisession:
  [07:18:43.610]    - 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:18:43.610]    - tweaked: FALSE
  [07:18:43.610]    - call: plan(strategy, substitute = FALSE)
  [07:18:43.611] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [07:18:43.611] multisession:
  [07:18:43.611] - 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:18:43.611] - tweaked: FALSE
  [07:18:43.611] - call: plan(strategy, substitute = FALSE)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 22463
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/data/gannet/ripley/R/R-clang/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmphR90tl/future.parent=699463.aac472485273f.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmpi2dwzg/working_dir/RtmphR90tl/future.parent=699463.aac472485273f.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/dotdotdot.R:gannet.stats.ox.ac.uk:ripley:699463' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmphR90tl/future.parent=699463.aac472485273f.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=22463 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 699502) if still alive
  [07:20:44.457] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(699463, signal = 0L)
  [1] TRUE
  Call: tools::pskill(699463, signal = 0L)
  [1] TRUE
  [07:20:44.458] - success
  [07:20:44.459] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 699502) 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 22463 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/dotdotdot.R:gannet.stats.ox.ac.uk:ripley:699463' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmphR90tl/future.parent=699463.aac472485273f.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=22463 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 699502) 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:20:44.822] plan(): Setting new future strategy stack:
  [07:20:44.823] List of future strategies:
  [07:20:44.823] 1. sequential:
  [07:20:44.823]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:20:44.823]    - tweaked: FALSE
  [07:20:44.823]    - call: future::plan("sequential")
  [07:20:44.824] 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 33647 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/early-signaling.R:gannet.stats.ox.ac.uk:ripley:700286' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmpi2dwzg/working_dir/RtmpH7A0Gz/future.parent=700286.aaf7e1ed42ca8.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=33647 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 700319) 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:22:47.193] plan(): Setting new future strategy stack:
  [07:22:47.194] List of future strategies:
  [07:22:47.194] 1. sequential:
  [07:22:47.194]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.194]    - tweaked: FALSE
  [07:22:47.194]    - call: future::plan("sequential")
  [07:22:47.196] 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:22:47.211] getGlobalsAndPackages() ...
  [07:22:47.211] Searching for globals...
  [07:22:47.219] - globals found: [2] '{', 'cat'
  [07:22:47.220] Searching for globals ... DONE
  [07:22:47.220] Resolving globals: FALSE
  [07:22:47.221] 
  [07:22:47.221] 
  [07:22:47.222] 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:22:47.225] Packages needed by the future expression (n = 0): <none>
  [07:22:47.225] Packages needed by future strategies (n = 0): <none>
  [07:22:47.229] {
  [07:22:47.229]     {
  [07:22:47.229]         ...future.startTime <- base::Sys.time()
  [07:22:47.229]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:22:47.229]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:22:47.229]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [07:22:47.229]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:22:47.229]             future.resolve.recursive = NULL, width = 80L)
  [07:22:47.229]         {
  [07:22:47.229]             {
  [07:22:47.229]                 base::local({
  [07:22:47.229]                   has_future <- base::requireNamespace("future", 
  [07:22:47.229]                     quietly = TRUE)
  [07:22:47.229]                   version <- if (has_future) 
  [07:22:47.229]                     utils::packageVersion("future")
  [07:22:47.229]                   else NULL
  [07:22:47.229]                   if (!has_future || version < "1.8.0") {
  [07:22:47.229]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:22:47.229]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:22:47.229]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:22:47.229]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:22:47.229]                         "release", "version")], collapse = " "), 
  [07:22:47.229]                       hostname = base::Sys.info()[["nodename"]])
  [07:22:47.229]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:22:47.229]                       info)
  [07:22:47.229]                     info <- base::paste(info, collapse = "; ")
  [07:22:47.229]                     if (!has_future) {
  [07:22:47.229]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:22:47.229]                         info)
  [07:22:47.229]                     }
  [07:22:47.229]                     else {
  [07:22:47.229]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:22:47.229]                         info, version)
  [07:22:47.229]                     }
  [07:22:47.229]                     base::stop(msg)
  [07:22:47.229]                   }
  [07:22:47.229]                 })
  [07:22:47.229]             }
  [07:22:47.229]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:22:47.229]         }
  [07:22:47.229]     }
  [07:22:47.229]     if (base::is.na(TRUE)) {
  [07:22:47.229]     }
  [07:22:47.229]     else {
  [07:22:47.229]         if (TRUE) {
  [07:22:47.229]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:22:47.229]                 open = "w")
  [07:22:47.229]         }
  [07:22:47.229]         else {
  [07:22:47.229]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:22:47.229]                 windows = "NUL", "/dev/null"), open = "w")
  [07:22:47.229]         }
  [07:22:47.229]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:22:47.229]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:22:47.229]             base::sink(type = "output", split = FALSE)
  [07:22:47.229]             base::close(...future.stdout)
  [07:22:47.229]         }, add = TRUE)
  [07:22:47.229]     }
  [07:22:47.229]     ...future.frame <- base::sys.nframe()
  [07:22:47.229]     ...future.conditions <- base::list()
  [07:22:47.229]     ...future.rng <- base::globalenv()$.Random.seed
  [07:22:47.229]     ...future.result <- base::tryCatch({
  [07:22:47.229]         base::withCallingHandlers({
  [07:22:47.229]             ...future.value <- base::withVisible(base::local({
  [07:22:47.229]                 cat("Future assignment evaluated\n")
  [07:22:47.229]                 2
  [07:22:47.229]             }))
  [07:22:47.229]             future::FutureResult(value = ...future.value$value, 
  [07:22:47.229]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.229]                   ...future.rng), started = ...future.startTime, 
  [07:22:47.229]                 version = "1.8")
  [07:22:47.229]         }, condition = base::local({
  [07:22:47.229]             c <- base::c
  [07:22:47.229]             inherits <- base::inherits
  [07:22:47.229]             invokeRestart <- base::invokeRestart
  [07:22:47.229]             length <- base::length
  [07:22:47.229]             list <- base::list
  [07:22:47.229]             seq.int <- base::seq.int
  [07:22:47.229]             signalCondition <- base::signalCondition
  [07:22:47.229]             sys.calls <- base::sys.calls
  [07:22:47.229]             Sys.time <- base::Sys.time
  [07:22:47.229]             `[[` <- base::`[[`
  [07:22:47.229]             `+` <- base::`+`
  [07:22:47.229]             `<<-` <- base::`<<-`
  [07:22:47.229]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:22:47.229]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:22:47.229]                   3L)]
  [07:22:47.229]             }
  [07:22:47.229]             function(cond) {
  [07:22:47.229]                 if (inherits(cond, "error")) {
  [07:22:47.229]                   sessionInformation <- function() {
  [07:22:47.229]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:22:47.229]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:22:47.229]                       search = base::search(), system = base::Sys.info())
  [07:22:47.229]                   }
  [07:22:47.229]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.229]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:22:47.229]                     cond$call), session = sessionInformation(), 
  [07:22:47.229]                     timestamp = Sys.time(), signaled = 0L)
  [07:22:47.229]                   signalCondition(cond)
  [07:22:47.229]                 }
  [07:22:47.229]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:22:47.229]                 ))) {
  [07:22:47.229]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:22:47.229]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.229]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:22:47.229]                   if (!signal) {
  [07:22:47.229]                     muffleCondition <- function (cond) 
  [07:22:47.229]                     {
  [07:22:47.229]                       inherits <- base::inherits
  [07:22:47.229]                       invokeRestart <- base::invokeRestart
  [07:22:47.229]                       muffled <- FALSE
  [07:22:47.229]                       if (inherits(cond, "message")) {
  [07:22:47.229]                         invokeRestart("muffleMessage")
  [07:22:47.229]                         muffled <- TRUE
  [07:22:47.229]                       }
  [07:22:47.229]                       else if (inherits(cond, "warning")) {
  [07:22:47.229]                         invokeRestart("muffleWarning")
  [07:22:47.229]                         muffled <- TRUE
  [07:22:47.229]                       }
  [07:22:47.229]                       else if (inherits(cond, "condition")) {
  [07:22:47.229]                         computeRestarts <- base::computeRestarts
  [07:22:47.229]                         grepl <- base::grepl
  [07:22:47.229]                         is.null <- base::is.null
  [07:22:47.229]                         restarts <- computeRestarts(cond)
  [07:22:47.229]                         for (restart in restarts) {
  [07:22:47.229]                           name <- restart$name
  [07:22:47.229]                           if (is.null(name)) 
  [07:22:47.229]                             next
  [07:22:47.229]                           if (!grepl("^muffle", name)) 
  [07:22:47.229]                             next
  [07:22:47.229]                           invokeRestart(restart)
  [07:22:47.229]                           muffled <- TRUE
  [07:22:47.229]                           break
  [07:22:47.229]                         }
  [07:22:47.229]                       }
  [07:22:47.229]                       invisible(muffled)
  [07:22:47.229]                     }
  [07:22:47.229]                     muffleCondition(cond)
  [07:22:47.229]                   }
  [07:22:47.229]                 }
  [07:22:47.229]             }
  [07:22:47.229]         }))
  [07:22:47.229]     }, error = function(ex) {
  [07:22:47.229]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:22:47.229]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.229]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:22:47.229]     }, finally = {
  [07:22:47.229]         {
  [07:22:47.229]             NULL
  [07:22:47.229]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:22:47.229]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:22:47.229]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:22:47.229]                 label = NULL, ...) 
  [07:22:47.229]             {
  [07:22:47.229]                 if (substitute) 
  [07:22:47.229]                   expr <- substitute(expr)
  [07:22:47.229]                 local <- as.logical(local)
  [07:22:47.229]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:22:47.229]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:22:47.229]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:22:47.229]                   label = label, ...)
  [07:22:47.229]                 if (!future$lazy) 
  [07:22:47.229]                   future <- run(future)
  [07:22:47.229]                 invisible(future)
  [07:22:47.229]             }), .cleanup = FALSE, .init = FALSE)
  [07:22:47.229]         }
  [07:22:47.229]         base::options(...future.oldOptions)
  [07:22:47.229]     })
  [07:22:47.229]     Sys.time
  [07:22:47.229]     if (base::is.na(TRUE)) {
  [07:22:47.229]     }
  [07:22:47.229]     else {
  [07:22:47.229]         base::sink(type = "output", split = FALSE)
  [07:22:47.229]         if (TRUE) {
  [07:22:47.229]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:22:47.229]         }
  [07:22:47.229]         else {
  [07:22:47.229]             ...future.result["stdout"] <- base::list(NULL)
  [07:22:47.229]         }
  [07:22:47.229]         base::close(...future.stdout)
  [07:22:47.229]         ...future.stdout <- NULL
  [07:22:47.229]     }
  [07:22:47.229]     ...future.result$conditions <- ...future.conditions
  [07:22:47.229]     ...future.result
  [07:22:47.229] }
  [07:22:47.234] plan(): Setting new future strategy stack:
  [07:22:47.234] List of future strategies:
  [07:22:47.234] 1. sequential:
  [07:22:47.234]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.234]    - tweaked: FALSE
  [07:22:47.234]    - call: NULL
  [07:22:47.235] plan(): nbrOfWorkers() = 1
  [07:22:47.236] plan(): Setting new future strategy stack:
  [07:22:47.236] List of future strategies:
  [07:22:47.236] 1. sequential:
  [07:22:47.236]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.236]    - tweaked: FALSE
  [07:22:47.236]    - call: future::plan("sequential")
  [07:22:47.237] plan(): nbrOfWorkers() = 1
  [07:22:47.237] 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:22:47.293] plan(): Setting new future strategy stack:
  [07:22:47.293] List of future strategies:
  [07:22:47.293] 1. sequential:
  [07:22:47.293]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.293]    - tweaked: FALSE
  [07:22:47.293]    - call: plan(strategy)
  [07:22:47.314] plan(): nbrOfWorkers() = 1
  [07:22:47.314] getGlobalsAndPackages() ...
  [07:22:47.314] Searching for globals...
  [07:22:47.315] - globals found: [1] '{'
  [07:22:47.315] Searching for globals ... DONE
  [07:22:47.316] Resolving globals: FALSE
  [07:22:47.316] 
  [07:22:47.317] 
  [07:22:47.317] getGlobalsAndPackages() ... DONE
  [07:22:47.318] Packages needed by the future expression (n = 0): <none>
  [07:22:47.318] Packages needed by future strategies (n = 0): <none>
  [07:22:47.322] {
  [07:22:47.322]     {
  [07:22:47.322]         ...future.startTime <- base::Sys.time()
  [07:22:47.322]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:22:47.322]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:22:47.322]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:22:47.322]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:22:47.322]             future.resolve.recursive = NULL, width = 80L)
  [07:22:47.322]         {
  [07:22:47.322]             {
  [07:22:47.322]                 base::local({
  [07:22:47.322]                   has_future <- base::requireNamespace("future", 
  [07:22:47.322]                     quietly = TRUE)
  [07:22:47.322]                   version <- if (has_future) 
  [07:22:47.322]                     utils::packageVersion("future")
  [07:22:47.322]                   else NULL
  [07:22:47.322]                   if (!has_future || version < "1.8.0") {
  [07:22:47.322]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:22:47.322]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:22:47.322]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:22:47.322]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:22:47.322]                         "release", "version")], collapse = " "), 
  [07:22:47.322]                       hostname = base::Sys.info()[["nodename"]])
  [07:22:47.322]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:22:47.322]                       info)
  [07:22:47.322]                     info <- base::paste(info, collapse = "; ")
  [07:22:47.322]                     if (!has_future) {
  [07:22:47.322]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:22:47.322]                         info)
  [07:22:47.322]                     }
  [07:22:47.322]                     else {
  [07:22:47.322]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:22:47.322]                         info, version)
  [07:22:47.322]                     }
  [07:22:47.322]                     base::stop(msg)
  [07:22:47.322]                   }
  [07:22:47.322]                 })
  [07:22:47.322]             }
  [07:22:47.322]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:22:47.322]         }
  [07:22:47.322]     }
  [07:22:47.322]     if (base::is.na(TRUE)) {
  [07:22:47.322]     }
  [07:22:47.322]     else {
  [07:22:47.322]         if (TRUE) {
  [07:22:47.322]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:22:47.322]                 open = "w")
  [07:22:47.322]         }
  [07:22:47.322]         else {
  [07:22:47.322]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:22:47.322]                 windows = "NUL", "/dev/null"), open = "w")
  [07:22:47.322]         }
  [07:22:47.322]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:22:47.322]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:22:47.322]             base::sink(type = "output", split = FALSE)
  [07:22:47.322]             base::close(...future.stdout)
  [07:22:47.322]         }, add = TRUE)
  [07:22:47.322]     }
  [07:22:47.322]     ...future.frame <- base::sys.nframe()
  [07:22:47.322]     ...future.conditions <- base::list()
  [07:22:47.322]     ...future.rng <- base::globalenv()$.Random.seed
  [07:22:47.322]     ...future.result <- base::tryCatch({
  [07:22:47.322]         base::withCallingHandlers({
  [07:22:47.322]             ...future.value <- base::withVisible(base::local({
  [07:22:47.322]                 2
  [07:22:47.322]             }))
  [07:22:47.322]             future::FutureResult(value = ...future.value$value, 
  [07:22:47.322]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.322]                   ...future.rng), started = ...future.startTime, 
  [07:22:47.322]                 version = "1.8")
  [07:22:47.322]         }, condition = base::local({
  [07:22:47.322]             c <- base::c
  [07:22:47.322]             inherits <- base::inherits
  [07:22:47.322]             invokeRestart <- base::invokeRestart
  [07:22:47.322]             length <- base::length
  [07:22:47.322]             list <- base::list
  [07:22:47.322]             seq.int <- base::seq.int
  [07:22:47.322]             signalCondition <- base::signalCondition
  [07:22:47.322]             sys.calls <- base::sys.calls
  [07:22:47.322]             Sys.time <- base::Sys.time
  [07:22:47.322]             `[[` <- base::`[[`
  [07:22:47.322]             `+` <- base::`+`
  [07:22:47.322]             `<<-` <- base::`<<-`
  [07:22:47.322]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:22:47.322]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:22:47.322]                   3L)]
  [07:22:47.322]             }
  [07:22:47.322]             function(cond) {
  [07:22:47.322]                 if (inherits(cond, "error")) {
  [07:22:47.322]                   sessionInformation <- function() {
  [07:22:47.322]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:22:47.322]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:22:47.322]                       search = base::search(), system = base::Sys.info())
  [07:22:47.322]                   }
  [07:22:47.322]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.322]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:22:47.322]                     cond$call), session = sessionInformation(), 
  [07:22:47.322]                     timestamp = Sys.time(), signaled = 0L)
  [07:22:47.322]                   signalCondition(cond)
  [07:22:47.322]                 }
  [07:22:47.322]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:22:47.322]                 ))) {
  [07:22:47.322]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:22:47.322]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.322]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:22:47.322]                   if (!signal) {
  [07:22:47.322]                     muffleCondition <- function (cond) 
  [07:22:47.322]                     {
  [07:22:47.322]                       inherits <- base::inherits
  [07:22:47.322]                       invokeRestart <- base::invokeRestart
  [07:22:47.322]                       muffled <- FALSE
  [07:22:47.322]                       if (inherits(cond, "message")) {
  [07:22:47.322]                         invokeRestart("muffleMessage")
  [07:22:47.322]                         muffled <- TRUE
  [07:22:47.322]                       }
  [07:22:47.322]                       else if (inherits(cond, "warning")) {
  [07:22:47.322]                         invokeRestart("muffleWarning")
  [07:22:47.322]                         muffled <- TRUE
  [07:22:47.322]                       }
  [07:22:47.322]                       else if (inherits(cond, "condition")) {
  [07:22:47.322]                         computeRestarts <- base::computeRestarts
  [07:22:47.322]                         grepl <- base::grepl
  [07:22:47.322]                         is.null <- base::is.null
  [07:22:47.322]                         restarts <- computeRestarts(cond)
  [07:22:47.322]                         for (restart in restarts) {
  [07:22:47.322]                           name <- restart$name
  [07:22:47.322]                           if (is.null(name)) 
  [07:22:47.322]                             next
  [07:22:47.322]                           if (!grepl("^muffle", name)) 
  [07:22:47.322]                             next
  [07:22:47.322]                           invokeRestart(restart)
  [07:22:47.322]                           muffled <- TRUE
  [07:22:47.322]                           break
  [07:22:47.322]                         }
  [07:22:47.322]                       }
  [07:22:47.322]                       invisible(muffled)
  [07:22:47.322]                     }
  [07:22:47.322]                     muffleCondition(cond)
  [07:22:47.322]                   }
  [07:22:47.322]                 }
  [07:22:47.322]             }
  [07:22:47.322]         }))
  [07:22:47.322]     }, error = function(ex) {
  [07:22:47.322]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:22:47.322]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.322]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:22:47.322]     }, finally = {
  [07:22:47.322]         {
  [07:22:47.322]             NULL
  [07:22:47.322]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:22:47.322]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:22:47.322]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:22:47.322]                 label = NULL, ...) 
  [07:22:47.322]             {
  [07:22:47.322]                 if (substitute) 
  [07:22:47.322]                   expr <- substitute(expr)
  [07:22:47.322]                 local <- as.logical(local)
  [07:22:47.322]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:22:47.322]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:22:47.322]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:22:47.322]                   label = label, ...)
  [07:22:47.322]                 if (!future$lazy) 
  [07:22:47.322]                   future <- run(future)
  [07:22:47.322]                 invisible(future)
  [07:22:47.322]             }), .cleanup = FALSE, .init = FALSE)
  [07:22:47.322]         }
  [07:22:47.322]         base::options(...future.oldOptions)
  [07:22:47.322]     })
  [07:22:47.322]     Sys.time
  [07:22:47.322]     if (base::is.na(TRUE)) {
  [07:22:47.322]     }
  [07:22:47.322]     else {
  [07:22:47.322]         base::sink(type = "output", split = FALSE)
  [07:22:47.322]         if (TRUE) {
  [07:22:47.322]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:22:47.322]         }
  [07:22:47.322]         else {
  [07:22:47.322]             ...future.result["stdout"] <- base::list(NULL)
  [07:22:47.322]         }
  [07:22:47.322]         base::close(...future.stdout)
  [07:22:47.322]         ...future.stdout <- NULL
  [07:22:47.322]     }
  [07:22:47.322]     ...future.result$conditions <- ...future.conditions
  [07:22:47.322]     ...future.result
  [07:22:47.322] }
  [07:22:47.326] plan(): Setting new future strategy stack:
  [07:22:47.326] List of future strategies:
  [07:22:47.326] 1. sequential:
  [07:22:47.326]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.326]    - tweaked: FALSE
  [07:22:47.326]    - call: NULL
  [07:22:47.327] plan(): nbrOfWorkers() = 1
  [07:22:47.327] plan(): Setting new future strategy stack:
  [07:22:47.328] List of future strategies:
  [07:22:47.328] 1. sequential:
  [07:22:47.328]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.328]    - tweaked: FALSE
  [07:22:47.328]    - call: plan(strategy)
  [07:22:47.328] plan(): nbrOfWorkers() = 1
  [07:22:47.329] SequentialFuture started (and completed)
  [07:22:47.329] getGlobalsAndPackages() ...
  [07:22:47.330] Searching for globals...
  [07:22:47.330] - globals found: [1] '{'
  [07:22:47.331] Searching for globals ... DONE
  [07:22:47.331] Resolving globals: FALSE
  [07:22:47.332] 
  [07:22:47.332] 
  [07:22:47.332] getGlobalsAndPackages() ... DONE
  [07:22:47.333] Packages needed by the future expression (n = 0): <none>
  [07:22:47.334] Packages needed by future strategies (n = 0): <none>
  [07:22:47.337] {
  [07:22:47.337]     {
  [07:22:47.337]         ...future.startTime <- base::Sys.time()
  [07:22:47.337]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:22:47.337]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:22:47.337]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:22:47.337]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:22:47.337]             future.resolve.recursive = NULL, width = 80L)
  [07:22:47.337]         {
  [07:22:47.337]             {
  [07:22:47.337]                 base::local({
  [07:22:47.337]                   has_future <- base::requireNamespace("future", 
  [07:22:47.337]                     quietly = TRUE)
  [07:22:47.337]                   version <- if (has_future) 
  [07:22:47.337]                     utils::packageVersion("future")
  [07:22:47.337]                   else NULL
  [07:22:47.337]                   if (!has_future || version < "1.8.0") {
  [07:22:47.337]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:22:47.337]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:22:47.337]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:22:47.337]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:22:47.337]                         "release", "version")], collapse = " "), 
  [07:22:47.337]                       hostname = base::Sys.info()[["nodename"]])
  [07:22:47.337]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:22:47.337]                       info)
  [07:22:47.337]                     info <- base::paste(info, collapse = "; ")
  [07:22:47.337]                     if (!has_future) {
  [07:22:47.337]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:22:47.337]                         info)
  [07:22:47.337]                     }
  [07:22:47.337]                     else {
  [07:22:47.337]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:22:47.337]                         info, version)
  [07:22:47.337]                     }
  [07:22:47.337]                     base::stop(msg)
  [07:22:47.337]                   }
  [07:22:47.337]                 })
  [07:22:47.337]             }
  [07:22:47.337]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:22:47.337]         }
  [07:22:47.337]     }
  [07:22:47.337]     if (base::is.na(TRUE)) {
  [07:22:47.337]     }
  [07:22:47.337]     else {
  [07:22:47.337]         if (TRUE) {
  [07:22:47.337]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:22:47.337]                 open = "w")
  [07:22:47.337]         }
  [07:22:47.337]         else {
  [07:22:47.337]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:22:47.337]                 windows = "NUL", "/dev/null"), open = "w")
  [07:22:47.337]         }
  [07:22:47.337]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:22:47.337]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:22:47.337]             base::sink(type = "output", split = FALSE)
  [07:22:47.337]             base::close(...future.stdout)
  [07:22:47.337]         }, add = TRUE)
  [07:22:47.337]     }
  [07:22:47.337]     ...future.frame <- base::sys.nframe()
  [07:22:47.337]     ...future.conditions <- base::list()
  [07:22:47.337]     ...future.rng <- base::globalenv()$.Random.seed
  [07:22:47.337]     ...future.result <- base::tryCatch({
  [07:22:47.337]         base::withCallingHandlers({
  [07:22:47.337]             ...future.value <- base::withVisible(base::local({
  [07:22:47.337]                 4
  [07:22:47.337]             }))
  [07:22:47.337]             future::FutureResult(value = ...future.value$value, 
  [07:22:47.337]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.337]                   ...future.rng), started = ...future.startTime, 
  [07:22:47.337]                 version = "1.8")
  [07:22:47.337]         }, condition = base::local({
  [07:22:47.337]             c <- base::c
  [07:22:47.337]             inherits <- base::inherits
  [07:22:47.337]             invokeRestart <- base::invokeRestart
  [07:22:47.337]             length <- base::length
  [07:22:47.337]             list <- base::list
  [07:22:47.337]             seq.int <- base::seq.int
  [07:22:47.337]             signalCondition <- base::signalCondition
  [07:22:47.337]             sys.calls <- base::sys.calls
  [07:22:47.337]             Sys.time <- base::Sys.time
  [07:22:47.337]             `[[` <- base::`[[`
  [07:22:47.337]             `+` <- base::`+`
  [07:22:47.337]             `<<-` <- base::`<<-`
  [07:22:47.337]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:22:47.337]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:22:47.337]                   3L)]
  [07:22:47.337]             }
  [07:22:47.337]             function(cond) {
  [07:22:47.337]                 if (inherits(cond, "error")) {
  [07:22:47.337]                   sessionInformation <- function() {
  [07:22:47.337]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:22:47.337]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:22:47.337]                       search = base::search(), system = base::Sys.info())
  [07:22:47.337]                   }
  [07:22:47.337]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.337]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:22:47.337]                     cond$call), session = sessionInformation(), 
  [07:22:47.337]                     timestamp = Sys.time(), signaled = 0L)
  [07:22:47.337]                   signalCondition(cond)
  [07:22:47.337]                 }
  [07:22:47.337]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:22:47.337]                 ))) {
  [07:22:47.337]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:22:47.337]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.337]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:22:47.337]                   if (!signal) {
  [07:22:47.337]                     muffleCondition <- function (cond) 
  [07:22:47.337]                     {
  [07:22:47.337]                       inherits <- base::inherits
  [07:22:47.337]                       invokeRestart <- base::invokeRestart
  [07:22:47.337]                       muffled <- FALSE
  [07:22:47.337]                       if (inherits(cond, "message")) {
  [07:22:47.337]                         invokeRestart("muffleMessage")
  [07:22:47.337]                         muffled <- TRUE
  [07:22:47.337]                       }
  [07:22:47.337]                       else if (inherits(cond, "warning")) {
  [07:22:47.337]                         invokeRestart("muffleWarning")
  [07:22:47.337]                         muffled <- TRUE
  [07:22:47.337]                       }
  [07:22:47.337]                       else if (inherits(cond, "condition")) {
  [07:22:47.337]                         computeRestarts <- base::computeRestarts
  [07:22:47.337]                         grepl <- base::grepl
  [07:22:47.337]                         is.null <- base::is.null
  [07:22:47.337]                         restarts <- computeRestarts(cond)
  [07:22:47.337]                         for (restart in restarts) {
  [07:22:47.337]                           name <- restart$name
  [07:22:47.337]                           if (is.null(name)) 
  [07:22:47.337]                             next
  [07:22:47.337]                           if (!grepl("^muffle", name)) 
  [07:22:47.337]                             next
  [07:22:47.337]                           invokeRestart(restart)
  [07:22:47.337]                           muffled <- TRUE
  [07:22:47.337]                           break
  [07:22:47.337]                         }
  [07:22:47.337]                       }
  [07:22:47.337]                       invisible(muffled)
  [07:22:47.337]                     }
  [07:22:47.337]                     muffleCondition(cond)
  [07:22:47.337]                   }
  [07:22:47.337]                 }
  [07:22:47.337]             }
  [07:22:47.337]         }))
  [07:22:47.337]     }, error = function(ex) {
  [07:22:47.337]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:22:47.337]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.337]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:22:47.337]     }, finally = {
  [07:22:47.337]         {
  [07:22:47.337]             NULL
  [07:22:47.337]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:22:47.337]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:22:47.337]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:22:47.337]                 label = NULL, ...) 
  [07:22:47.337]             {
  [07:22:47.337]                 if (substitute) 
  [07:22:47.337]                   expr <- substitute(expr)
  [07:22:47.337]                 local <- as.logical(local)
  [07:22:47.337]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:22:47.337]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:22:47.337]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:22:47.337]                   label = label, ...)
  [07:22:47.337]                 if (!future$lazy) 
  [07:22:47.337]                   future <- run(future)
  [07:22:47.337]                 invisible(future)
  [07:22:47.337]             }), .cleanup = FALSE, .init = FALSE)
  [07:22:47.337]         }
  [07:22:47.337]         base::options(...future.oldOptions)
  [07:22:47.337]     })
  [07:22:47.337]     Sys.time
  [07:22:47.337]     if (base::is.na(TRUE)) {
  [07:22:47.337]     }
  [07:22:47.337]     else {
  [07:22:47.337]         base::sink(type = "output", split = FALSE)
  [07:22:47.337]         if (TRUE) {
  [07:22:47.337]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:22:47.337]         }
  [07:22:47.337]         else {
  [07:22:47.337]             ...future.result["stdout"] <- base::list(NULL)
  [07:22:47.337]         }
  [07:22:47.337]         base::close(...future.stdout)
  [07:22:47.337]         ...future.stdout <- NULL
  [07:22:47.337]     }
  [07:22:47.337]     ...future.result$conditions <- ...future.conditions
  [07:22:47.337]     ...future.result
  [07:22:47.337] }
  [07:22:47.341] plan(): Setting new future strategy stack:
  [07:22:47.341] List of future strategies:
  [07:22:47.341] 1. sequential:
  [07:22:47.341]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.341]    - tweaked: FALSE
  [07:22:47.341]    - call: NULL
  [07:22:47.342] plan(): nbrOfWorkers() = 1
  [07:22:47.342] plan(): Setting new future strategy stack:
  [07:22:47.343] List of future strategies:
  [07:22:47.343] 1. sequential:
  [07:22:47.343]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.343]    - tweaked: FALSE
  [07:22:47.343]    - call: plan(strategy)
  [07:22:47.343] plan(): nbrOfWorkers() = 1
  [07:22:47.344] SequentialFuture started (and completed)
  u$a = 2
  v$a = 4
  [07:22:47.345] getGlobalsAndPackages() ...
  [07:22:47.345] Searching for globals...
  [07:22:47.346] - globals found: [3] '{', '*', 'a'
  [07:22:47.346] Searching for globals ... DONE
  [07:22:47.347] Resolving globals: FALSE
  [07:22:47.348] The total size of the 1 globals is 56 bytes (56 bytes)
  [07:22:47.348] - globals: [1] 'a'
  [07:22:47.348] 
  [07:22:47.349] getGlobalsAndPackages() ... DONE
  [07:22:47.350] Packages needed by the future expression (n = 0): <none>
  [07:22:47.350] Packages needed by future strategies (n = 0): <none>
  [07:22:47.353] {
  [07:22:47.353]     {
  [07:22:47.353]         ...future.startTime <- base::Sys.time()
  [07:22:47.353]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:22:47.353]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:22:47.353]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:22:47.353]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:22:47.353]             future.resolve.recursive = NULL, width = 80L)
  [07:22:47.353]         {
  [07:22:47.353]             {
  [07:22:47.353]                 base::local({
  [07:22:47.353]                   has_future <- base::requireNamespace("future", 
  [07:22:47.353]                     quietly = TRUE)
  [07:22:47.353]                   version <- if (has_future) 
  [07:22:47.353]                     utils::packageVersion("future")
  [07:22:47.353]                   else NULL
  [07:22:47.353]                   if (!has_future || version < "1.8.0") {
  [07:22:47.353]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:22:47.353]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:22:47.353]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:22:47.353]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:22:47.353]                         "release", "version")], collapse = " "), 
  [07:22:47.353]                       hostname = base::Sys.info()[["nodename"]])
  [07:22:47.353]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:22:47.353]                       info)
  [07:22:47.353]                     info <- base::paste(info, collapse = "; ")
  [07:22:47.353]                     if (!has_future) {
  [07:22:47.353]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:22:47.353]                         info)
  [07:22:47.353]                     }
  [07:22:47.353]                     else {
  [07:22:47.353]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:22:47.353]                         info, version)
  [07:22:47.353]                     }
  [07:22:47.353]                     base::stop(msg)
  [07:22:47.353]                   }
  [07:22:47.353]                 })
  [07:22:47.353]             }
  [07:22:47.353]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:22:47.353]         }
  [07:22:47.353]     }
  [07:22:47.353]     if (base::is.na(TRUE)) {
  [07:22:47.353]     }
  [07:22:47.353]     else {
  [07:22:47.353]         if (TRUE) {
  [07:22:47.353]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:22:47.353]                 open = "w")
  [07:22:47.353]         }
  [07:22:47.353]         else {
  [07:22:47.353]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:22:47.353]                 windows = "NUL", "/dev/null"), open = "w")
  [07:22:47.353]         }
  [07:22:47.353]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:22:47.353]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:22:47.353]             base::sink(type = "output", split = FALSE)
  [07:22:47.353]             base::close(...future.stdout)
  [07:22:47.353]         }, add = TRUE)
  [07:22:47.353]     }
  [07:22:47.353]     ...future.frame <- base::sys.nframe()
  [07:22:47.353]     ...future.conditions <- base::list()
  [07:22:47.353]     ...future.rng <- base::globalenv()$.Random.seed
  [07:22:47.353]     ...future.result <- base::tryCatch({
  [07:22:47.353]         base::withCallingHandlers({
  [07:22:47.353]             ...future.value <- base::withVisible(base::local({
  [07:22:47.353]                 2 * a
  [07:22:47.353]             }))
  [07:22:47.353]             future::FutureResult(value = ...future.value$value, 
  [07:22:47.353]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.353]                   ...future.rng), started = ...future.startTime, 
  [07:22:47.353]                 version = "1.8")
  [07:22:47.353]         }, condition = base::local({
  [07:22:47.353]             c <- base::c
  [07:22:47.353]             inherits <- base::inherits
  [07:22:47.353]             invokeRestart <- base::invokeRestart
  [07:22:47.353]             length <- base::length
  [07:22:47.353]             list <- base::list
  [07:22:47.353]             seq.int <- base::seq.int
  [07:22:47.353]             signalCondition <- base::signalCondition
  [07:22:47.353]             sys.calls <- base::sys.calls
  [07:22:47.353]             Sys.time <- base::Sys.time
  [07:22:47.353]             `[[` <- base::`[[`
  [07:22:47.353]             `+` <- base::`+`
  [07:22:47.353]             `<<-` <- base::`<<-`
  [07:22:47.353]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:22:47.353]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:22:47.353]                   3L)]
  [07:22:47.353]             }
  [07:22:47.353]             function(cond) {
  [07:22:47.353]                 if (inherits(cond, "error")) {
  [07:22:47.353]                   sessionInformation <- function() {
  [07:22:47.353]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:22:47.353]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:22:47.353]                       search = base::search(), system = base::Sys.info())
  [07:22:47.353]                   }
  [07:22:47.353]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.353]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:22:47.353]                     cond$call), session = sessionInformation(), 
  [07:22:47.353]                     timestamp = Sys.time(), signaled = 0L)
  [07:22:47.353]                   signalCondition(cond)
  [07:22:47.353]                 }
  [07:22:47.353]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:22:47.353]                 ))) {
  [07:22:47.353]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:22:47.353]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.353]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:22:47.353]                   if (!signal) {
  [07:22:47.353]                     muffleCondition <- function (cond) 
  [07:22:47.353]                     {
  [07:22:47.353]                       inherits <- base::inherits
  [07:22:47.353]                       invokeRestart <- base::invokeRestart
  [07:22:47.353]                       muffled <- FALSE
  [07:22:47.353]                       if (inherits(cond, "message")) {
  [07:22:47.353]                         invokeRestart("muffleMessage")
  [07:22:47.353]                         muffled <- TRUE
  [07:22:47.353]                       }
  [07:22:47.353]                       else if (inherits(cond, "warning")) {
  [07:22:47.353]                         invokeRestart("muffleWarning")
  [07:22:47.353]                         muffled <- TRUE
  [07:22:47.353]                       }
  [07:22:47.353]                       else if (inherits(cond, "condition")) {
  [07:22:47.353]                         computeRestarts <- base::computeRestarts
  [07:22:47.353]                         grepl <- base::grepl
  [07:22:47.353]                         is.null <- base::is.null
  [07:22:47.353]                         restarts <- computeRestarts(cond)
  [07:22:47.353]                         for (restart in restarts) {
  [07:22:47.353]                           name <- restart$name
  [07:22:47.353]                           if (is.null(name)) 
  [07:22:47.353]                             next
  [07:22:47.353]                           if (!grepl("^muffle", name)) 
  [07:22:47.353]                             next
  [07:22:47.353]                           invokeRestart(restart)
  [07:22:47.353]                           muffled <- TRUE
  [07:22:47.353]                           break
  [07:22:47.353]                         }
  [07:22:47.353]                       }
  [07:22:47.353]                       invisible(muffled)
  [07:22:47.353]                     }
  [07:22:47.353]                     muffleCondition(cond)
  [07:22:47.353]                   }
  [07:22:47.353]                 }
  [07:22:47.353]             }
  [07:22:47.353]         }))
  [07:22:47.353]     }, error = function(ex) {
  [07:22:47.353]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:22:47.353]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.353]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:22:47.353]     }, finally = {
  [07:22:47.353]         {
  [07:22:47.353]             NULL
  [07:22:47.353]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:22:47.353]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:22:47.353]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:22:47.353]                 label = NULL, ...) 
  [07:22:47.353]             {
  [07:22:47.353]                 if (substitute) 
  [07:22:47.353]                   expr <- substitute(expr)
  [07:22:47.353]                 local <- as.logical(local)
  [07:22:47.353]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:22:47.353]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:22:47.353]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:22:47.353]                   label = label, ...)
  [07:22:47.353]                 if (!future$lazy) 
  [07:22:47.353]                   future <- run(future)
  [07:22:47.353]                 invisible(future)
  [07:22:47.353]             }), .cleanup = FALSE, .init = FALSE)
  [07:22:47.353]         }
  [07:22:47.353]         base::options(...future.oldOptions)
  [07:22:47.353]     })
  [07:22:47.353]     Sys.time
  [07:22:47.353]     if (base::is.na(TRUE)) {
  [07:22:47.353]     }
  [07:22:47.353]     else {
  [07:22:47.353]         base::sink(type = "output", split = FALSE)
  [07:22:47.353]         if (TRUE) {
  [07:22:47.353]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:22:47.353]         }
  [07:22:47.353]         else {
  [07:22:47.353]             ...future.result["stdout"] <- base::list(NULL)
  [07:22:47.353]         }
  [07:22:47.353]         base::close(...future.stdout)
  [07:22:47.353]         ...future.stdout <- NULL
  [07:22:47.353]     }
  [07:22:47.353]     ...future.result$conditions <- ...future.conditions
  [07:22:47.353]     ...future.result
  [07:22:47.353] }
  [07:22:47.357] plan(): Setting new future strategy stack:
  [07:22:47.357] List of future strategies:
  [07:22:47.357] 1. sequential:
  [07:22:47.357]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.357]    - tweaked: FALSE
  [07:22:47.357]    - call: NULL
  [07:22:47.358] plan(): nbrOfWorkers() = 1
  [07:22:47.359] plan(): Setting new future strategy stack:
  [07:22:47.359] List of future strategies:
  [07:22:47.359] 1. sequential:
  [07:22:47.359]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.359]    - tweaked: FALSE
  [07:22:47.359]    - call: plan(strategy)
  [07:22:47.360] plan(): nbrOfWorkers() = 1
  [07:22:47.360] SequentialFuture started (and completed)
  [07:22:47.361] getGlobalsAndPackages() ...
  [07:22:47.361] Searching for globals...
  [07:22:47.362] - globals found: [3] '{', '*', 'a'
  [07:22:47.363] Searching for globals ... DONE
  [07:22:47.363] Resolving globals: FALSE
  [07:22:47.363] The total size of the 1 globals is 56 bytes (56 bytes)
  [07:22:47.366] - globals: [1] 'a'
  [07:22:47.366] 
  [07:22:47.366] getGlobalsAndPackages() ... DONE
  [07:22:47.367] Packages needed by the future expression (n = 0): <none>
  [07:22:47.368] Packages needed by future strategies (n = 0): <none>
  [07:22:47.371] {
  [07:22:47.371]     {
  [07:22:47.371]         ...future.startTime <- base::Sys.time()
  [07:22:47.371]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:22:47.371]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:22:47.371]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:22:47.371]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:22:47.371]             future.resolve.recursive = NULL, width = 80L)
  [07:22:47.371]         {
  [07:22:47.371]             {
  [07:22:47.371]                 base::local({
  [07:22:47.371]                   has_future <- base::requireNamespace("future", 
  [07:22:47.371]                     quietly = TRUE)
  [07:22:47.371]                   version <- if (has_future) 
  [07:22:47.371]                     utils::packageVersion("future")
  [07:22:47.371]                   else NULL
  [07:22:47.371]                   if (!has_future || version < "1.8.0") {
  [07:22:47.371]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:22:47.371]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:22:47.371]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:22:47.371]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:22:47.371]                         "release", "version")], collapse = " "), 
  [07:22:47.371]                       hostname = base::Sys.info()[["nodename"]])
  [07:22:47.371]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:22:47.371]                       info)
  [07:22:47.371]                     info <- base::paste(info, collapse = "; ")
  [07:22:47.371]                     if (!has_future) {
  [07:22:47.371]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:22:47.371]                         info)
  [07:22:47.371]                     }
  [07:22:47.371]                     else {
  [07:22:47.371]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:22:47.371]                         info, version)
  [07:22:47.371]                     }
  [07:22:47.371]                     base::stop(msg)
  [07:22:47.371]                   }
  [07:22:47.371]                 })
  [07:22:47.371]             }
  [07:22:47.371]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:22:47.371]         }
  [07:22:47.371]     }
  [07:22:47.371]     if (base::is.na(TRUE)) {
  [07:22:47.371]     }
  [07:22:47.371]     else {
  [07:22:47.371]         if (TRUE) {
  [07:22:47.371]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:22:47.371]                 open = "w")
  [07:22:47.371]         }
  [07:22:47.371]         else {
  [07:22:47.371]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:22:47.371]                 windows = "NUL", "/dev/null"), open = "w")
  [07:22:47.371]         }
  [07:22:47.371]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:22:47.371]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:22:47.371]             base::sink(type = "output", split = FALSE)
  [07:22:47.371]             base::close(...future.stdout)
  [07:22:47.371]         }, add = TRUE)
  [07:22:47.371]     }
  [07:22:47.371]     ...future.frame <- base::sys.nframe()
  [07:22:47.371]     ...future.conditions <- base::list()
  [07:22:47.371]     ...future.rng <- base::globalenv()$.Random.seed
  [07:22:47.371]     ...future.result <- base::tryCatch({
  [07:22:47.371]         base::withCallingHandlers({
  [07:22:47.371]             ...future.value <- base::withVisible(base::local({
  [07:22:47.371]                 2 * a
  [07:22:47.371]             }))
  [07:22:47.371]             future::FutureResult(value = ...future.value$value, 
  [07:22:47.371]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.371]                   ...future.rng), started = ...future.startTime, 
  [07:22:47.371]                 version = "1.8")
  [07:22:47.371]         }, condition = base::local({
  [07:22:47.371]             c <- base::c
  [07:22:47.371]             inherits <- base::inherits
  [07:22:47.371]             invokeRestart <- base::invokeRestart
  [07:22:47.371]             length <- base::length
  [07:22:47.371]             list <- base::list
  [07:22:47.371]             seq.int <- base::seq.int
  [07:22:47.371]             signalCondition <- base::signalCondition
  [07:22:47.371]             sys.calls <- base::sys.calls
  [07:22:47.371]             Sys.time <- base::Sys.time
  [07:22:47.371]             `[[` <- base::`[[`
  [07:22:47.371]             `+` <- base::`+`
  [07:22:47.371]             `<<-` <- base::`<<-`
  [07:22:47.371]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:22:47.371]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:22:47.371]                   3L)]
  [07:22:47.371]             }
  [07:22:47.371]             function(cond) {
  [07:22:47.371]                 if (inherits(cond, "error")) {
  [07:22:47.371]                   sessionInformation <- function() {
  [07:22:47.371]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:22:47.371]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:22:47.371]                       search = base::search(), system = base::Sys.info())
  [07:22:47.371]                   }
  [07:22:47.371]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.371]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:22:47.371]                     cond$call), session = sessionInformation(), 
  [07:22:47.371]                     timestamp = Sys.time(), signaled = 0L)
  [07:22:47.371]                   signalCondition(cond)
  [07:22:47.371]                 }
  [07:22:47.371]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:22:47.371]                 ))) {
  [07:22:47.371]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:22:47.371]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.371]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:22:47.371]                   if (!signal) {
  [07:22:47.371]                     muffleCondition <- function (cond) 
  [07:22:47.371]                     {
  [07:22:47.371]                       inherits <- base::inherits
  [07:22:47.371]                       invokeRestart <- base::invokeRestart
  [07:22:47.371]                       muffled <- FALSE
  [07:22:47.371]                       if (inherits(cond, "message")) {
  [07:22:47.371]                         invokeRestart("muffleMessage")
  [07:22:47.371]                         muffled <- TRUE
  [07:22:47.371]                       }
  [07:22:47.371]                       else if (inherits(cond, "warning")) {
  [07:22:47.371]                         invokeRestart("muffleWarning")
  [07:22:47.371]                         muffled <- TRUE
  [07:22:47.371]                       }
  [07:22:47.371]                       else if (inherits(cond, "condition")) {
  [07:22:47.371]                         computeRestarts <- base::computeRestarts
  [07:22:47.371]                         grepl <- base::grepl
  [07:22:47.371]                         is.null <- base::is.null
  [07:22:47.371]                         restarts <- computeRestarts(cond)
  [07:22:47.371]                         for (restart in restarts) {
  [07:22:47.371]                           name <- restart$name
  [07:22:47.371]                           if (is.null(name)) 
  [07:22:47.371]                             next
  [07:22:47.371]                           if (!grepl("^muffle", name)) 
  [07:22:47.371]                             next
  [07:22:47.371]                           invokeRestart(restart)
  [07:22:47.371]                           muffled <- TRUE
  [07:22:47.371]                           break
  [07:22:47.371]                         }
  [07:22:47.371]                       }
  [07:22:47.371]                       invisible(muffled)
  [07:22:47.371]                     }
  [07:22:47.371]                     muffleCondition(cond)
  [07:22:47.371]                   }
  [07:22:47.371]                 }
  [07:22:47.371]             }
  [07:22:47.371]         }))
  [07:22:47.371]     }, error = function(ex) {
  [07:22:47.371]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:22:47.371]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.371]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:22:47.371]     }, finally = {
  [07:22:47.371]         {
  [07:22:47.371]             NULL
  [07:22:47.371]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:22:47.371]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:22:47.371]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:22:47.371]                 label = NULL, ...) 
  [07:22:47.371]             {
  [07:22:47.371]                 if (substitute) 
  [07:22:47.371]                   expr <- substitute(expr)
  [07:22:47.371]                 local <- as.logical(local)
  [07:22:47.371]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:22:47.371]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:22:47.371]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:22:47.371]                   label = label, ...)
  [07:22:47.371]                 if (!future$lazy) 
  [07:22:47.371]                   future <- run(future)
  [07:22:47.371]                 invisible(future)
  [07:22:47.371]             }), .cleanup = FALSE, .init = FALSE)
  [07:22:47.371]         }
  [07:22:47.371]         base::options(...future.oldOptions)
  [07:22:47.371]     })
  [07:22:47.371]     Sys.time
  [07:22:47.371]     if (base::is.na(TRUE)) {
  [07:22:47.371]     }
  [07:22:47.371]     else {
  [07:22:47.371]         base::sink(type = "output", split = FALSE)
  [07:22:47.371]         if (TRUE) {
  [07:22:47.371]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:22:47.371]         }
  [07:22:47.371]         else {
  [07:22:47.371]             ...future.result["stdout"] <- base::list(NULL)
  [07:22:47.371]         }
  [07:22:47.371]         base::close(...future.stdout)
  [07:22:47.371]         ...future.stdout <- NULL
  [07:22:47.371]     }
  [07:22:47.371]     ...future.result$conditions <- ...future.conditions
  [07:22:47.371]     ...future.result
  [07:22:47.371] }
  [07:22:47.375] plan(): Setting new future strategy stack:
  [07:22:47.375] List of future strategies:
  [07:22:47.375] 1. sequential:
  [07:22:47.375]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.375]    - tweaked: FALSE
  [07:22:47.375]    - call: NULL
  [07:22:47.376] plan(): nbrOfWorkers() = 1
  [07:22:47.377] plan(): Setting new future strategy stack:
  [07:22:47.377] List of future strategies:
  [07:22:47.377] 1. sequential:
  [07:22:47.377]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.377]    - tweaked: FALSE
  [07:22:47.377]    - call: plan(strategy)
  [07:22:47.378] plan(): nbrOfWorkers() = 1
  [07:22:47.378] SequentialFuture started (and completed)
  [07:22:47.379] getGlobalsAndPackages() ...
  [07:22:47.379] Searching for globals...
  [07:22:47.380] - globals found: [3] '{', '*', 'a'
  [07:22:47.381] Searching for globals ... DONE
  [07:22:47.381] Resolving globals: FALSE
  [07:22:47.382] The total size of the 1 globals is 56 bytes (56 bytes)
  [07:22:47.382] - globals: [1] 'a'
  [07:22:47.382] 
  [07:22:47.383] getGlobalsAndPackages() ... DONE
  [07:22:47.384] Packages needed by the future expression (n = 0): <none>
  [07:22:47.384] Packages needed by future strategies (n = 0): <none>
  [07:22:47.388] {
  [07:22:47.388]     {
  [07:22:47.388]         ...future.startTime <- base::Sys.time()
  [07:22:47.388]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:22:47.388]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:22:47.388]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:22:47.388]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:22:47.388]             future.resolve.recursive = NULL, width = 80L)
  [07:22:47.388]         {
  [07:22:47.388]             {
  [07:22:47.388]                 base::local({
  [07:22:47.388]                   has_future <- base::requireNamespace("future", 
  [07:22:47.388]                     quietly = TRUE)
  [07:22:47.388]                   version <- if (has_future) 
  [07:22:47.388]                     utils::packageVersion("future")
  [07:22:47.388]                   else NULL
  [07:22:47.388]                   if (!has_future || version < "1.8.0") {
  [07:22:47.388]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:22:47.388]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:22:47.388]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:22:47.388]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:22:47.388]                         "release", "version")], collapse = " "), 
  [07:22:47.388]                       hostname = base::Sys.info()[["nodename"]])
  [07:22:47.388]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:22:47.388]                       info)
  [07:22:47.388]                     info <- base::paste(info, collapse = "; ")
  [07:22:47.388]                     if (!has_future) {
  [07:22:47.388]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:22:47.388]                         info)
  [07:22:47.388]                     }
  [07:22:47.388]                     else {
  [07:22:47.388]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:22:47.388]                         info, version)
  [07:22:47.388]                     }
  [07:22:47.388]                     base::stop(msg)
  [07:22:47.388]                   }
  [07:22:47.388]                 })
  [07:22:47.388]             }
  [07:22:47.388]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:22:47.388]         }
  [07:22:47.388]     }
  [07:22:47.388]     if (base::is.na(TRUE)) {
  [07:22:47.388]     }
  [07:22:47.388]     else {
  [07:22:47.388]         if (TRUE) {
  [07:22:47.388]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:22:47.388]                 open = "w")
  [07:22:47.388]         }
  [07:22:47.388]         else {
  [07:22:47.388]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:22:47.388]                 windows = "NUL", "/dev/null"), open = "w")
  [07:22:47.388]         }
  [07:22:47.388]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:22:47.388]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:22:47.388]             base::sink(type = "output", split = FALSE)
  [07:22:47.388]             base::close(...future.stdout)
  [07:22:47.388]         }, add = TRUE)
  [07:22:47.388]     }
  [07:22:47.388]     ...future.frame <- base::sys.nframe()
  [07:22:47.388]     ...future.conditions <- base::list()
  [07:22:47.388]     ...future.rng <- base::globalenv()$.Random.seed
  [07:22:47.388]     ...future.result <- base::tryCatch({
  [07:22:47.388]         base::withCallingHandlers({
  [07:22:47.388]             ...future.value <- base::withVisible(base::local({
  [07:22:47.388]                 2 * a
  [07:22:47.388]             }))
  [07:22:47.388]             future::FutureResult(value = ...future.value$value, 
  [07:22:47.388]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.388]                   ...future.rng), started = ...future.startTime, 
  [07:22:47.388]                 version = "1.8")
  [07:22:47.388]         }, condition = base::local({
  [07:22:47.388]             c <- base::c
  [07:22:47.388]             inherits <- base::inherits
  [07:22:47.388]             invokeRestart <- base::invokeRestart
  [07:22:47.388]             length <- base::length
  [07:22:47.388]             list <- base::list
  [07:22:47.388]             seq.int <- base::seq.int
  [07:22:47.388]             signalCondition <- base::signalCondition
  [07:22:47.388]             sys.calls <- base::sys.calls
  [07:22:47.388]             Sys.time <- base::Sys.time
  [07:22:47.388]             `[[` <- base::`[[`
  [07:22:47.388]             `+` <- base::`+`
  [07:22:47.388]             `<<-` <- base::`<<-`
  [07:22:47.388]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:22:47.388]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:22:47.388]                   3L)]
  [07:22:47.388]             }
  [07:22:47.388]             function(cond) {
  [07:22:47.388]                 if (inherits(cond, "error")) {
  [07:22:47.388]                   sessionInformation <- function() {
  [07:22:47.388]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:22:47.388]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:22:47.388]                       search = base::search(), system = base::Sys.info())
  [07:22:47.388]                   }
  [07:22:47.388]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.388]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:22:47.388]                     cond$call), session = sessionInformation(), 
  [07:22:47.388]                     timestamp = Sys.time(), signaled = 0L)
  [07:22:47.388]                   signalCondition(cond)
  [07:22:47.388]                 }
  [07:22:47.388]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:22:47.388]                 ))) {
  [07:22:47.388]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:22:47.388]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.388]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:22:47.388]                   if (!signal) {
  [07:22:47.388]                     muffleCondition <- function (cond) 
  [07:22:47.388]                     {
  [07:22:47.388]                       inherits <- base::inherits
  [07:22:47.388]                       invokeRestart <- base::invokeRestart
  [07:22:47.388]                       muffled <- FALSE
  [07:22:47.388]                       if (inherits(cond, "message")) {
  [07:22:47.388]                         invokeRestart("muffleMessage")
  [07:22:47.388]                         muffled <- TRUE
  [07:22:47.388]                       }
  [07:22:47.388]                       else if (inherits(cond, "warning")) {
  [07:22:47.388]                         invokeRestart("muffleWarning")
  [07:22:47.388]                         muffled <- TRUE
  [07:22:47.388]                       }
  [07:22:47.388]                       else if (inherits(cond, "condition")) {
  [07:22:47.388]                         computeRestarts <- base::computeRestarts
  [07:22:47.388]                         grepl <- base::grepl
  [07:22:47.388]                         is.null <- base::is.null
  [07:22:47.388]                         restarts <- computeRestarts(cond)
  [07:22:47.388]                         for (restart in restarts) {
  [07:22:47.388]                           name <- restart$name
  [07:22:47.388]                           if (is.null(name)) 
  [07:22:47.388]                             next
  [07:22:47.388]                           if (!grepl("^muffle", name)) 
  [07:22:47.388]                             next
  [07:22:47.388]                           invokeRestart(restart)
  [07:22:47.388]                           muffled <- TRUE
  [07:22:47.388]                           break
  [07:22:47.388]                         }
  [07:22:47.388]                       }
  [07:22:47.388]                       invisible(muffled)
  [07:22:47.388]                     }
  [07:22:47.388]                     muffleCondition(cond)
  [07:22:47.388]                   }
  [07:22:47.388]                 }
  [07:22:47.388]             }
  [07:22:47.388]         }))
  [07:22:47.388]     }, error = function(ex) {
  [07:22:47.388]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:22:47.388]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.388]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:22:47.388]     }, finally = {
  [07:22:47.388]         {
  [07:22:47.388]             NULL
  [07:22:47.388]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:22:47.388]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:22:47.388]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:22:47.388]                 label = NULL, ...) 
  [07:22:47.388]             {
  [07:22:47.388]                 if (substitute) 
  [07:22:47.388]                   expr <- substitute(expr)
  [07:22:47.388]                 local <- as.logical(local)
  [07:22:47.388]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:22:47.388]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:22:47.388]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:22:47.388]                   label = label, ...)
  [07:22:47.388]                 if (!future$lazy) 
  [07:22:47.388]                   future <- run(future)
  [07:22:47.388]                 invisible(future)
  [07:22:47.388]             }), .cleanup = FALSE, .init = FALSE)
  [07:22:47.388]         }
  [07:22:47.388]         base::options(...future.oldOptions)
  [07:22:47.388]     })
  [07:22:47.388]     Sys.time
  [07:22:47.388]     if (base::is.na(TRUE)) {
  [07:22:47.388]     }
  [07:22:47.388]     else {
  [07:22:47.388]         base::sink(type = "output", split = FALSE)
  [07:22:47.388]         if (TRUE) {
  [07:22:47.388]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:22:47.388]         }
  [07:22:47.388]         else {
  [07:22:47.388]             ...future.result["stdout"] <- base::list(NULL)
  [07:22:47.388]         }
  [07:22:47.388]         base::close(...future.stdout)
  [07:22:47.388]         ...future.stdout <- NULL
  [07:22:47.388]     }
  [07:22:47.388]     ...future.result$conditions <- ...future.conditions
  [07:22:47.388]     ...future.result
  [07:22:47.388] }
  [07:22:47.391] plan(): Setting new future strategy stack:
  [07:22:47.392] List of future strategies:
  [07:22:47.392] 1. sequential:
  [07:22:47.392]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.392]    - tweaked: FALSE
  [07:22:47.392]    - call: NULL
  [07:22:47.392] plan(): nbrOfWorkers() = 1
  [07:22:47.393] plan(): Setting new future strategy stack:
  [07:22:47.394] List of future strategies:
  [07:22:47.394] 1. sequential:
  [07:22:47.394]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.394]    - tweaked: FALSE
  [07:22:47.394]    - call: plan(strategy)
  [07:22:47.394] plan(): nbrOfWorkers() = 1
  [07:22:47.395] SequentialFuture started (and completed)
  [07:22:47.395] getGlobalsAndPackages() ...
  [07:22:47.396] Searching for globals...
  [07:22:47.397] - globals found: [3] '{', '*', 'a'
  [07:22:47.397] Searching for globals ... DONE
  [07:22:47.397] Resolving globals: FALSE
  [07:22:47.398] The total size of the 1 globals is 56 bytes (56 bytes)
  [07:22:47.398] - globals: [1] 'a'
  [07:22:47.399] 
  [07:22:47.399] getGlobalsAndPackages() ... DONE
  [07:22:47.400] Packages needed by the future expression (n = 0): <none>
  [07:22:47.401] Packages needed by future strategies (n = 0): <none>
  [07:22:47.404] {
  [07:22:47.404]     {
  [07:22:47.404]         ...future.startTime <- base::Sys.time()
  [07:22:47.404]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:22:47.404]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:22:47.404]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:22:47.404]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:22:47.404]             future.resolve.recursive = NULL, width = 80L)
  [07:22:47.404]         {
  [07:22:47.404]             {
  [07:22:47.404]                 base::local({
  [07:22:47.404]                   has_future <- base::requireNamespace("future", 
  [07:22:47.404]                     quietly = TRUE)
  [07:22:47.404]                   version <- if (has_future) 
  [07:22:47.404]                     utils::packageVersion("future")
  [07:22:47.404]                   else NULL
  [07:22:47.404]                   if (!has_future || version < "1.8.0") {
  [07:22:47.404]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:22:47.404]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:22:47.404]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:22:47.404]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:22:47.404]                         "release", "version")], collapse = " "), 
  [07:22:47.404]                       hostname = base::Sys.info()[["nodename"]])
  [07:22:47.404]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:22:47.404]                       info)
  [07:22:47.404]                     info <- base::paste(info, collapse = "; ")
  [07:22:47.404]                     if (!has_future) {
  [07:22:47.404]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:22:47.404]                         info)
  [07:22:47.404]                     }
  [07:22:47.404]                     else {
  [07:22:47.404]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:22:47.404]                         info, version)
  [07:22:47.404]                     }
  [07:22:47.404]                     base::stop(msg)
  [07:22:47.404]                   }
  [07:22:47.404]                 })
  [07:22:47.404]             }
  [07:22:47.404]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:22:47.404]         }
  [07:22:47.404]     }
  [07:22:47.404]     if (base::is.na(TRUE)) {
  [07:22:47.404]     }
  [07:22:47.404]     else {
  [07:22:47.404]         if (TRUE) {
  [07:22:47.404]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:22:47.404]                 open = "w")
  [07:22:47.404]         }
  [07:22:47.404]         else {
  [07:22:47.404]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:22:47.404]                 windows = "NUL", "/dev/null"), open = "w")
  [07:22:47.404]         }
  [07:22:47.404]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:22:47.404]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:22:47.404]             base::sink(type = "output", split = FALSE)
  [07:22:47.404]             base::close(...future.stdout)
  [07:22:47.404]         }, add = TRUE)
  [07:22:47.404]     }
  [07:22:47.404]     ...future.frame <- base::sys.nframe()
  [07:22:47.404]     ...future.conditions <- base::list()
  [07:22:47.404]     ...future.rng <- base::globalenv()$.Random.seed
  [07:22:47.404]     ...future.result <- base::tryCatch({
  [07:22:47.404]         base::withCallingHandlers({
  [07:22:47.404]             ...future.value <- base::withVisible(base::local({
  [07:22:47.404]                 2 * a
  [07:22:47.404]             }))
  [07:22:47.404]             future::FutureResult(value = ...future.value$value, 
  [07:22:47.404]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.404]                   ...future.rng), started = ...future.startTime, 
  [07:22:47.404]                 version = "1.8")
  [07:22:47.404]         }, condition = base::local({
  [07:22:47.404]             c <- base::c
  [07:22:47.404]             inherits <- base::inherits
  [07:22:47.404]             invokeRestart <- base::invokeRestart
  [07:22:47.404]             length <- base::length
  [07:22:47.404]             list <- base::list
  [07:22:47.404]             seq.int <- base::seq.int
  [07:22:47.404]             signalCondition <- base::signalCondition
  [07:22:47.404]             sys.calls <- base::sys.calls
  [07:22:47.404]             Sys.time <- base::Sys.time
  [07:22:47.404]             `[[` <- base::`[[`
  [07:22:47.404]             `+` <- base::`+`
  [07:22:47.404]             `<<-` <- base::`<<-`
  [07:22:47.404]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:22:47.404]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:22:47.404]                   3L)]
  [07:22:47.404]             }
  [07:22:47.404]             function(cond) {
  [07:22:47.404]                 if (inherits(cond, "error")) {
  [07:22:47.404]                   sessionInformation <- function() {
  [07:22:47.404]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:22:47.404]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:22:47.404]                       search = base::search(), system = base::Sys.info())
  [07:22:47.404]                   }
  [07:22:47.404]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.404]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:22:47.404]                     cond$call), session = sessionInformation(), 
  [07:22:47.404]                     timestamp = Sys.time(), signaled = 0L)
  [07:22:47.404]                   signalCondition(cond)
  [07:22:47.404]                 }
  [07:22:47.404]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:22:47.404]                 ))) {
  [07:22:47.404]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:22:47.404]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.404]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:22:47.404]                   if (!signal) {
  [07:22:47.404]                     muffleCondition <- function (cond) 
  [07:22:47.404]                     {
  [07:22:47.404]                       inherits <- base::inherits
  [07:22:47.404]                       invokeRestart <- base::invokeRestart
  [07:22:47.404]                       muffled <- FALSE
  [07:22:47.404]                       if (inherits(cond, "message")) {
  [07:22:47.404]                         invokeRestart("muffleMessage")
  [07:22:47.404]                         muffled <- TRUE
  [07:22:47.404]                       }
  [07:22:47.404]                       else if (inherits(cond, "warning")) {
  [07:22:47.404]                         invokeRestart("muffleWarning")
  [07:22:47.404]                         muffled <- TRUE
  [07:22:47.404]                       }
  [07:22:47.404]                       else if (inherits(cond, "condition")) {
  [07:22:47.404]                         computeRestarts <- base::computeRestarts
  [07:22:47.404]                         grepl <- base::grepl
  [07:22:47.404]                         is.null <- base::is.null
  [07:22:47.404]                         restarts <- computeRestarts(cond)
  [07:22:47.404]                         for (restart in restarts) {
  [07:22:47.404]                           name <- restart$name
  [07:22:47.404]                           if (is.null(name)) 
  [07:22:47.404]                             next
  [07:22:47.404]                           if (!grepl("^muffle", name)) 
  [07:22:47.404]                             next
  [07:22:47.404]                           invokeRestart(restart)
  [07:22:47.404]                           muffled <- TRUE
  [07:22:47.404]                           break
  [07:22:47.404]                         }
  [07:22:47.404]                       }
  [07:22:47.404]                       invisible(muffled)
  [07:22:47.404]                     }
  [07:22:47.404]                     muffleCondition(cond)
  [07:22:47.404]                   }
  [07:22:47.404]                 }
  [07:22:47.404]             }
  [07:22:47.404]         }))
  [07:22:47.404]     }, error = function(ex) {
  [07:22:47.404]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:22:47.404]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.404]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:22:47.404]     }, finally = {
  [07:22:47.404]         {
  [07:22:47.404]             NULL
  [07:22:47.404]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:22:47.404]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:22:47.404]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:22:47.404]                 label = NULL, ...) 
  [07:22:47.404]             {
  [07:22:47.404]                 if (substitute) 
  [07:22:47.404]                   expr <- substitute(expr)
  [07:22:47.404]                 local <- as.logical(local)
  [07:22:47.404]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:22:47.404]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:22:47.404]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:22:47.404]                   label = label, ...)
  [07:22:47.404]                 if (!future$lazy) 
  [07:22:47.404]                   future <- run(future)
  [07:22:47.404]                 invisible(future)
  [07:22:47.404]             }), .cleanup = FALSE, .init = FALSE)
  [07:22:47.404]         }
  [07:22:47.404]         base::options(...future.oldOptions)
  [07:22:47.404]     })
  [07:22:47.404]     Sys.time
  [07:22:47.404]     if (base::is.na(TRUE)) {
  [07:22:47.404]     }
  [07:22:47.404]     else {
  [07:22:47.404]         base::sink(type = "output", split = FALSE)
  [07:22:47.404]         if (TRUE) {
  [07:22:47.404]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:22:47.404]         }
  [07:22:47.404]         else {
  [07:22:47.404]             ...future.result["stdout"] <- base::list(NULL)
  [07:22:47.404]         }
  [07:22:47.404]         base::close(...future.stdout)
  [07:22:47.404]         ...future.stdout <- NULL
  [07:22:47.404]     }
  [07:22:47.404]     ...future.result$conditions <- ...future.conditions
  [07:22:47.404]     ...future.result
  [07:22:47.404] }
  [07:22:47.408] plan(): Setting new future strategy stack:
  [07:22:47.408] List of future strategies:
  [07:22:47.408] 1. sequential:
  [07:22:47.408]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.408]    - tweaked: FALSE
  [07:22:47.408]    - call: NULL
  [07:22:47.409] plan(): nbrOfWorkers() = 1
  [07:22:47.409] plan(): Setting new future strategy stack:
  [07:22:47.410] List of future strategies:
  [07:22:47.410] 1. sequential:
  [07:22:47.410]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.410]    - tweaked: FALSE
  [07:22:47.410]    - call: plan(strategy)
  [07:22:47.410] plan(): nbrOfWorkers() = 1
  [07:22:47.411] SequentialFuture started (and completed)
  [07:22:47.411] getGlobalsAndPackages() ...
  [07:22:47.412] Searching for globals...
  [07:22:47.413] - globals found: [3] '{', '*', 'a'
  [07:22:47.413] Searching for globals ... DONE
  [07:22:47.413] Resolving globals: FALSE
  [07:22:47.414] The total size of the 1 globals is 56 bytes (56 bytes)
  [07:22:47.414] - globals: [1] 'a'
  [07:22:47.415] 
  [07:22:47.415] getGlobalsAndPackages() ... DONE
  [07:22:47.416] Packages needed by the future expression (n = 0): <none>
  [07:22:47.417] Packages needed by future strategies (n = 0): <none>
  [07:22:47.420] {
  [07:22:47.420]     {
  [07:22:47.420]         ...future.startTime <- base::Sys.time()
  [07:22:47.420]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:22:47.420]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:22:47.420]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:22:47.420]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:22:47.420]             future.resolve.recursive = NULL, width = 80L)
  [07:22:47.420]         {
  [07:22:47.420]             {
  [07:22:47.420]                 base::local({
  [07:22:47.420]                   has_future <- base::requireNamespace("future", 
  [07:22:47.420]                     quietly = TRUE)
  [07:22:47.420]                   version <- if (has_future) 
  [07:22:47.420]                     utils::packageVersion("future")
  [07:22:47.420]                   else NULL
  [07:22:47.420]                   if (!has_future || version < "1.8.0") {
  [07:22:47.420]                     info <- base::c(r_version = base::gsub("R version ", 
  [07:22:47.420]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [07:22:47.420]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:22:47.420]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:22:47.420]                         "release", "version")], collapse = " "), 
  [07:22:47.420]                       hostname = base::Sys.info()[["nodename"]])
  [07:22:47.420]                     info <- base::sprintf("%s: %s", base::names(info), 
  [07:22:47.420]                       info)
  [07:22:47.420]                     info <- base::paste(info, collapse = "; ")
  [07:22:47.420]                     if (!has_future) {
  [07:22:47.420]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:22:47.420]                         info)
  [07:22:47.420]                     }
  [07:22:47.420]                     else {
  [07:22:47.420]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:22:47.420]                         info, version)
  [07:22:47.420]                     }
  [07:22:47.420]                     base::stop(msg)
  [07:22:47.420]                   }
  [07:22:47.420]                 })
  [07:22:47.420]             }
  [07:22:47.420]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:22:47.420]         }
  [07:22:47.420]     }
  [07:22:47.420]     if (base::is.na(TRUE)) {
  [07:22:47.420]     }
  [07:22:47.420]     else {
  [07:22:47.420]         if (TRUE) {
  [07:22:47.420]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:22:47.420]                 open = "w")
  [07:22:47.420]         }
  [07:22:47.420]         else {
  [07:22:47.420]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:22:47.420]                 windows = "NUL", "/dev/null"), open = "w")
  [07:22:47.420]         }
  [07:22:47.420]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:22:47.420]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:22:47.420]             base::sink(type = "output", split = FALSE)
  [07:22:47.420]             base::close(...future.stdout)
  [07:22:47.420]         }, add = TRUE)
  [07:22:47.420]     }
  [07:22:47.420]     ...future.frame <- base::sys.nframe()
  [07:22:47.420]     ...future.conditions <- base::list()
  [07:22:47.420]     ...future.rng <- base::globalenv()$.Random.seed
  [07:22:47.420]     ...future.result <- base::tryCatch({
  [07:22:47.420]         base::withCallingHandlers({
  [07:22:47.420]             ...future.value <- base::withVisible(base::local({
  [07:22:47.420]                 2 * a
  [07:22:47.420]             }))
  [07:22:47.420]             future::FutureResult(value = ...future.value$value, 
  [07:22:47.420]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.420]                   ...future.rng), started = ...future.startTime, 
  [07:22:47.420]                 version = "1.8")
  [07:22:47.420]         }, condition = base::local({
  [07:22:47.420]             c <- base::c
  [07:22:47.420]             inherits <- base::inherits
  [07:22:47.420]             invokeRestart <- base::invokeRestart
  [07:22:47.420]             length <- base::length
  [07:22:47.420]             list <- base::list
  [07:22:47.420]             seq.int <- base::seq.int
  [07:22:47.420]             signalCondition <- base::signalCondition
  [07:22:47.420]             sys.calls <- base::sys.calls
  [07:22:47.420]             Sys.time <- base::Sys.time
  [07:22:47.420]             `[[` <- base::`[[`
  [07:22:47.420]             `+` <- base::`+`
  [07:22:47.420]             `<<-` <- base::`<<-`
  [07:22:47.420]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:22:47.420]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:22:47.420]                   3L)]
  [07:22:47.420]             }
  [07:22:47.420]             function(cond) {
  [07:22:47.420]                 if (inherits(cond, "error")) {
  [07:22:47.420]                   sessionInformation <- function() {
  [07:22:47.420]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:22:47.420]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:22:47.420]                       search = base::search(), system = base::Sys.info())
  [07:22:47.420]                   }
  [07:22:47.420]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.420]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:22:47.420]                     cond$call), session = sessionInformation(), 
  [07:22:47.420]                     timestamp = Sys.time(), signaled = 0L)
  [07:22:47.420]                   signalCondition(cond)
  [07:22:47.420]                 }
  [07:22:47.420]                 else if (inherits(cond, c("condition", "immediateCondition"
  [07:22:47.420]                 ))) {
  [07:22:47.420]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [07:22:47.420]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.420]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:22:47.420]                   if (!signal) {
  [07:22:47.420]                     muffleCondition <- function (cond) 
  [07:22:47.420]                     {
  [07:22:47.420]                       inherits <- base::inherits
  [07:22:47.420]                       invokeRestart <- base::invokeRestart
  [07:22:47.420]                       muffled <- FALSE
  [07:22:47.420]                       if (inherits(cond, "message")) {
  [07:22:47.420]                         invokeRestart("muffleMessage")
  [07:22:47.420]                         muffled <- TRUE
  [07:22:47.420]                       }
  [07:22:47.420]                       else if (inherits(cond, "warning")) {
  [07:22:47.420]                         invokeRestart("muffleWarning")
  [07:22:47.420]                         muffled <- TRUE
  [07:22:47.420]                       }
  [07:22:47.420]                       else if (inherits(cond, "condition")) {
  [07:22:47.420]                         computeRestarts <- base::computeRestarts
  [07:22:47.420]                         grepl <- base::grepl
  [07:22:47.420]                         is.null <- base::is.null
  [07:22:47.420]                         restarts <- computeRestarts(cond)
  [07:22:47.420]                         for (restart in restarts) {
  [07:22:47.420]                           name <- restart$name
  [07:22:47.420]                           if (is.null(name)) 
  [07:22:47.420]                             next
  [07:22:47.420]                           if (!grepl("^muffle", name)) 
  [07:22:47.420]                             next
  [07:22:47.420]                           invokeRestart(restart)
  [07:22:47.420]                           muffled <- TRUE
  [07:22:47.420]                           break
  [07:22:47.420]                         }
  [07:22:47.420]                       }
  [07:22:47.420]                       invisible(muffled)
  [07:22:47.420]                     }
  [07:22:47.420]                     muffleCondition(cond)
  [07:22:47.420]                   }
  [07:22:47.420]                 }
  [07:22:47.420]             }
  [07:22:47.420]         }))
  [07:22:47.420]     }, error = function(ex) {
  [07:22:47.420]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:22:47.420]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.420]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:22:47.420]     }, finally = {
  [07:22:47.420]         {
  [07:22:47.420]             NULL
  [07:22:47.420]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:22:47.420]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:22:47.420]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [07:22:47.420]                 label = NULL, ...) 
  [07:22:47.420]             {
  [07:22:47.420]                 if (substitute) 
  [07:22:47.420]                   expr <- substitute(expr)
  [07:22:47.420]                 local <- as.logical(local)
  [07:22:47.420]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [07:22:47.420]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:22:47.420]                   globals = globals, local = local, earlySignal = earlySignal, 
  [07:22:47.420]                   label = label, ...)
  [07:22:47.420]                 if (!future$lazy) 
  [07:22:47.420]                   future <- run(future)
  [07:22:47.420]                 invisible(future)
  [07:22:47.420]             }), .cleanup = FALSE, .init = FALSE)
  [07:22:47.420]         }
  [07:22:47.420]         base::options(...future.oldOptions)
  [07:22:47.420]     })
  [07:22:47.420]     Sys.time
  [07:22:47.420]     if (base::is.na(TRUE)) {
  [07:22:47.420]     }
  [07:22:47.420]     else {
  [07:22:47.420]         base::sink(type = "output", split = FALSE)
  [07:22:47.420]         if (TRUE) {
  [07:22:47.420]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:22:47.420]         }
  [07:22:47.420]         else {
  [07:22:47.420]             ...future.result["stdout"] <- base::list(NULL)
  [07:22:47.420]         }
  [07:22:47.420]         base::close(...future.stdout)
  [07:22:47.420]         ...future.stdout <- NULL
  [07:22:47.420]     }
  [07:22:47.420]     ...future.result$conditions <- ...future.conditions
  [07:22:47.420]     ...future.result
  [07:22:47.420] }
  [07:22:47.424] plan(): Setting new future strategy stack:
  [07:22:47.424] List of future strategies:
  [07:22:47.424] 1. sequential:
  [07:22:47.424]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.424]    - tweaked: FALSE
  [07:22:47.424]    - call: NULL
  [07:22:47.425] plan(): nbrOfWorkers() = 1
  [07:22:47.427] plan(): Setting new future strategy stack:
  [07:22:47.428] List of future strategies:
  [07:22:47.428] 1. sequential:
  [07:22:47.428]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:22:47.428]    - tweaked: FALSE
  [07:22:47.428]    - call: plan(strategy)
  [07:22:47.428] plan(): nbrOfWorkers() = 1
  [07:22:47.429] SequentialFuture started (and completed)
  *** futureAssign() with 'sequential' futures ... DONE
  Testing with 1 cores ... DONE
  Testing with 2 cores ...
  *** futureAssign() with 'multicore' futures ...
  [07:22:47.437] plan(): Setting new future strategy stack:
  [07:22:47.437] List of future strategies:
  [07:22:47.437] 1. multicore:
  [07:22:47.437]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [07:22:47.437]    - tweaked: FALSE
  [07:22:47.437]    - call: plan(strategy)
  [07:22:47.438] plan(): nbrOfWorkers() = 2
  [07:22:47.439] getGlobalsAndPackages() ...
  [07:22:47.439] Searching for globals...
  [07:22:47.440] - globals found: [1] '{'
  [07:22:47.441] Searching for globals ... DONE
  [07:22:47.441] Resolving globals: FALSE
  [07:22:47.441] 
  [07:22:47.442] 
  [07:22:47.442] getGlobalsAndPackages() ... DONE
  [07:22:47.444] Packages needed by the future expression (n = 0): <none>
  [07:22:47.444] Packages needed by future strategies (n = 0): <none>
  [07:22:47.447] {
  [07:22:47.447]     {
  [07:22:47.447]         ...future.startTime <- base::Sys.time()
  [07:22:47.447]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [07:22:47.447]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [07:22:47.447]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [07:22:47.447]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [07:22:47.447]             future.resolve.recursive = NULL, width = 80L)
  [07:22:47.447]         {
  [07:22:47.447]             {
  [07:22:47.447]                 {
  [07:22:47.447]                   base::local({
  [07:22:47.447]                     has_future <- base::requireNamespace("future", 
  [07:22:47.447]                       quietly = TRUE)
  [07:22:47.447]                     version <- if (has_future) 
  [07:22:47.447]                       utils::packageVersion("future")
  [07:22:47.447]                     else NULL
  [07:22:47.447]                     if (!has_future || version < "1.8.0") {
  [07:22:47.447]                       info <- base::c(r_version = base::gsub("R version ", 
  [07:22:47.447]                         "", base::R.version$version.string), 
  [07:22:47.447]                         platform = base::sprintf("%s (%s-bit)", 
  [07:22:47.447]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [07:22:47.447]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [07:22:47.447]                           "release", "version")], collapse = " "), 
  [07:22:47.447]                         hostname = base::Sys.info()[["nodename"]])
  [07:22:47.447]                       info <- base::sprintf("%s: %s", base::names(info), 
  [07:22:47.447]                         info)
  [07:22:47.447]                       info <- base::paste(info, collapse = "; ")
  [07:22:47.447]                       if (!has_future) {
  [07:22:47.447]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [07:22:47.447]                           info)
  [07:22:47.447]                       }
  [07:22:47.447]                       else {
  [07:22:47.447]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [07:22:47.447]                           info, version)
  [07:22:47.447]                       }
  [07:22:47.447]                       base::stop(msg)
  [07:22:47.447]                     }
  [07:22:47.447]                   })
  [07:22:47.447]                 }
  [07:22:47.447]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [07:22:47.447]                 base::options(mc.cores = 1L)
  [07:22:47.447]             }
  [07:22:47.447]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [07:22:47.447]         }
  [07:22:47.447]     }
  [07:22:47.447]     if (base::is.na(TRUE)) {
  [07:22:47.447]     }
  [07:22:47.447]     else {
  [07:22:47.447]         if (TRUE) {
  [07:22:47.447]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [07:22:47.447]                 open = "w")
  [07:22:47.447]         }
  [07:22:47.447]         else {
  [07:22:47.447]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [07:22:47.447]                 windows = "NUL", "/dev/null"), open = "w")
  [07:22:47.447]         }
  [07:22:47.447]         base::sink(...future.stdout, type = "output", split = FALSE)
  [07:22:47.447]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [07:22:47.447]             base::sink(type = "output", split = FALSE)
  [07:22:47.447]             base::close(...future.stdout)
  [07:22:47.447]         }, add = TRUE)
  [07:22:47.447]     }
  [07:22:47.447]     ...future.frame <- base::sys.nframe()
  [07:22:47.447]     ...future.conditions <- base::list()
  [07:22:47.447]     ...future.rng <- base::globalenv()$.Random.seed
  [07:22:47.447]     ...future.result <- base::tryCatch({
  [07:22:47.447]         base::withCallingHandlers({
  [07:22:47.447]             ...future.value <- base::withVisible(base::local({
  [07:22:47.447]                 2
  [07:22:47.447]             }))
  [07:22:47.447]             future::FutureResult(value = ...future.value$value, 
  [07:22:47.447]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.447]                   ...future.rng), started = ...future.startTime, 
  [07:22:47.447]                 version = "1.8")
  [07:22:47.447]         }, condition = base::local({
  [07:22:47.447]             c <- base::c
  [07:22:47.447]             inherits <- base::inherits
  [07:22:47.447]             invokeRestart <- base::invokeRestart
  [07:22:47.447]             length <- base::length
  [07:22:47.447]             list <- base::list
  [07:22:47.447]             seq.int <- base::seq.int
  [07:22:47.447]             signalCondition <- base::signalCondition
  [07:22:47.447]             sys.calls <- base::sys.calls
  [07:22:47.447]             Sys.time <- base::Sys.time
  [07:22:47.447]             `[[` <- base::`[[`
  [07:22:47.447]             `+` <- base::`+`
  [07:22:47.447]             `<<-` <- base::`<<-`
  [07:22:47.447]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [07:22:47.447]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [07:22:47.447]                   3L)]
  [07:22:47.447]             }
  [07:22:47.447]             function(cond) {
  [07:22:47.447]                 if (inherits(cond, "error")) {
  [07:22:47.447]                   sessionInformation <- function() {
  [07:22:47.447]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [07:22:47.447]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [07:22:47.447]                       search = base::search(), system = base::Sys.info())
  [07:22:47.447]                   }
  [07:22:47.447]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.447]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [07:22:47.447]                     cond$call), session = sessionInformation(), 
  [07:22:47.447]                     timestamp = Sys.time(), signaled = 0L)
  [07:22:47.447]                   signalCondition(cond)
  [07:22:47.447]                 }
  [07:22:47.447]                 else if (inherits(cond, "condition")) {
  [07:22:47.447]                   signal <- FALSE && inherits(cond, character(0))
  [07:22:47.447]                   ...future.conditions[[length(...future.conditions) + 
  [07:22:47.447]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [07:22:47.447]                   if (!signal) {
  [07:22:47.447]                     muffleCondition <- function (cond) 
  [07:22:47.447]                     {
  [07:22:47.447]                       inherits <- base::inherits
  [07:22:47.447]                       invokeRestart <- base::invokeRestart
  [07:22:47.447]                       muffled <- FALSE
  [07:22:47.447]                       if (inherits(cond, "message")) {
  [07:22:47.447]                         invokeRestart("muffleMessage")
  [07:22:47.447]                         muffled <- TRUE
  [07:22:47.447]                       }
  [07:22:47.447]                       else if (inherits(cond, "warning")) {
  [07:22:47.447]                         invokeRestart("muffleWarning")
  [07:22:47.447]                         muffled <- TRUE
  [07:22:47.447]                       }
  [07:22:47.447]                       else if (inherits(cond, "condition")) {
  [07:22:47.447]                         computeRestarts <- base::computeRestarts
  [07:22:47.447]                         grepl <- base::grepl
  [07:22:47.447]                         is.null <- base::is.null
  [07:22:47.447]                         restarts <- computeRestarts(cond)
  [07:22:47.447]                         for (restart in restarts) {
  [07:22:47.447]                           name <- restart$name
  [07:22:47.447]                           if (is.null(name)) 
  [07:22:47.447]                             next
  [07:22:47.447]                           if (!grepl("^muffle", name)) 
  [07:22:47.447]                             next
  [07:22:47.447]                           invokeRestart(restart)
  [07:22:47.447]                           muffled <- TRUE
  [07:22:47.447]                           break
  [07:22:47.447]                         }
  [07:22:47.447]                       }
  [07:22:47.447]                       invisible(muffled)
  [07:22:47.447]                     }
  [07:22:47.447]                     muffleCondition(cond)
  [07:22:47.447]                   }
  [07:22:47.447]                 }
  [07:22:47.447]             }
  [07:22:47.447]         }))
  [07:22:47.447]     }, error = function(ex) {
  [07:22:47.447]         base::structure(base::list(value = NULL, visible = NULL, 
  [07:22:47.447]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [07:22:47.447]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [07:22:47.447]     }, finally = {
  [07:22:47.447]         {
  [07:22:47.447]             {
  [07:22:47.447]                 base::options(mc.cores = ...future.mc.cores.old)
  [07:22:47.447]             }
  [07:22:47.447]             future::plan(list(function (expr, envir = parent.frame(), 
  [07:22:47.447]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [07:22:47.447]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [07:22:47.447]                 earlySignal = FALSE, label = NULL, ...) 
  [07:22:47.447]             {
  [07:22:47.447]                 if (substitute) 
  [07:22:47.447]                   expr <- substitute(expr)
  [07:22:47.447]                 if (is.function(workers)) 
  [07:22:47.447]                   workers <- workers()
  [07:22:47.447]                 workers <- as.integer(workers)
  [07:22:47.447]                 stop_if_not(is.finite(workers), workers >= 1L)
  [07:22:47.447]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [07:22:47.447]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [07:22:47.447]                     lazy = lazy, seed = seed, globals = globals, 
  [07:22:47.447]                     local = TRUE, label = label, ...))
  [07:22:47.447]                 }
  [07:22:47.447]                 oopts <- options(mc.cores = workers)
  [07:22:47.447]                 on.exit(options(oopts))
  [07:22:47.447]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [07:22:47.447]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [07:22:47.447]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [07:22:47.447]                   label = label, ...)
  [07:22:47.447]                 if (!future$lazy) 
  [07:22:47.447]                   future <- run(future)
  [07:22:47.447]                 invisible(future)
  [07:22:47.447]             }), .cleanup = FALSE, .init = FALSE)
  [07:22:47.447]         }
  [07:22:47.447]         base::options(...future.oldOptions)
  [07:22:47.447]     })
  [07:22:47.447]     Sys.time
  [07:22:47.447]     if (base::is.na(TRUE)) {
  [07:22:47.447]     }
  [07:22:47.447]     else {
  [07:22:47.447]         base::sink(type = "output", split = FALSE)
  [07:22:47.447]         if (TRUE) {
  [07:22:47.447]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [07:22:47.447]         }
  [07:22:47.447]         else {
  [07:22:47.447]             ...future.result["stdout"] <- base::list(NULL)
  [07:22:47.447]         }
  [07:22:47.447]         base::close(...future.stdout)
  [07:22:47.447]         ...future.stdout <- NULL
  [07:22:47.447]     }
  [07:22:47.447]     ...future.result$conditions <- ...future.conditions
  [07:22:47.447]     ...future.result
  [07:22:47.447] }
  [07:22:47.450] requestCore(): workers = 2
  [07:22:47.455] MulticoreFuture started
  [07:22:47.457] getGlobalsAndPackages() ...
  [07:22:47.458] Searching for globals...
  [07:22:47.458] plan(): Setting new future strategy stack:
  [07:22:47.459] List of future strategies:
  [07:22:47.459] 1. sequential:
  [07:22:47.459]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = F