Running ‘DEPRECATED.R’ [1s/1s]
  Running ‘doRNG,dopar.R’ [1s/5s]
  Running ‘doRNG,dorng.R’ [2s/6s]
Running the tests in ‘tests/doRNG,dorng.R’ failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  Loading required package: foreach
  Loading required package: iterators
  Loading required package: parallel
  plan(): nbrOfWorkers() = 1
  > 
  > strategies <- future:::supportedStrategies()
  > strategies <- setdiff(strategies, "multiprocess")
  > 
  > ## Adopted from demo("doRNG", package = "doRNG")
  > if (require("doRNG")) {
  + 
  +   message("*** doFuture() w/ doRNG + %dorng% ...")
  +   print(sessionInfo())
  + 
  +   for (strategy in strategies) {
  +     message(sprintf("- plan('%s') ...", strategy))
  +     plan(strategy)
  + 
  +     # single %dorng% loops are reproducible
  +     r1 <- foreach(i = 1:4, .options.RNG = 1234) %dorng% { runif(1) }
  +     r2 <- foreach(i = 1:4, .options.RNG = 1234) %dorng% { runif(1) }
  +     str(list(r1 = r1, r2 = r2))
  +     stopifnot(identical(r1, r2))
  + 
  +     # sequences of %dorng% loops are reproducible
  +     set.seed(1234)
  +     s1 <- foreach(i = 1:4) %dorng% { runif(1) }
  +     s2 <- foreach(i = 1:4) %dorng% { runif(1) }
  +     str(list(s1 = s1, s2 = s2))
  +     # two consecutive (unseed) %dorng% loops are not identical
  +     stopifnot(!identical(s1, s2))
  +     # but the first one gives the same result as with .options.RNG
  +     stopifnot(identical(r1, s1))
  + 
  +     # But the whole sequence of loops is reproducible
  +     set.seed(1234)
  +     s1_2 <- foreach(i = 1:4) %dorng% { runif(1) }
  +     s2_2 <- foreach(i = 1:4) %dorng% { runif(1) }
  +     str(list(s1_2 = s1_2, s2_2 = s2_2))
  +     stopifnot(identical(s1, s1_2), identical(s2, s2_2))
  + 
  +     message(sprintf("- plan('%s') ... DONE", strategy))
  +   } ## for (strategy ...)
  + 
  +   message("*** doFuture() w/ doRNG + %dorng% ... DONE")
  + 
  + } ## if (require("doRNG"))
  Loading required package: doRNG
  Loading required package: rngtools
  Loading required package: pkgmaker
  Loading required package: registry
  
  Attaching package: 'pkgmaker'
  
  The following object is masked from 'package:base':
  
      isFALSE
  
  *** doFuture() w/ doRNG + %dorng% ...
  R Under development (unstable) (2018-07-26 r75007)
  Platform: x86_64-pc-linux-gnu (64-bit)
  Running under: Debian GNU/Linux buster/sid
  
  Matrix products: default
  BLAS: /home/hornik/tmp/R.check/r-devel-gcc/Work/build/lib/libRblas.so
  LAPACK: /home/hornik/tmp/R.check/r-devel-gcc/Work/build/lib/libRlapack.so
  
  locale:
   [1] LC_CTYPE=en_US.UTF-8       LC_NUMERIC=C              
   [3] LC_TIME=en_US.UTF-8        LC_COLLATE=C              
   [5] LC_MONETARY=en_US.UTF-8    LC_MESSAGES=en_US.UTF-8   
   [7] LC_PAPER=en_US.UTF-8       LC_NAME=C                 
   [9] LC_ADDRESS=C               LC_TELEPHONE=C            
  [11] LC_MEASUREMENT=en_US.UTF-8 LC_IDENTIFICATION=C       
  
  attached base packages:
  [1] parallel  stats     graphics  grDevices utils     datasets  methods  
  [8] base     
  
  other attached packages:
  [1] doRNG_1.7.1      rngtools_1.3.1   pkgmaker_0.27    registry_0.5    
  [5] doFuture_0.6.0   iterators_1.0.10 foreach_1.4.4    future_1.9.0    
  
  loaded via a namespace (and not attached):
   [1] codetools_0.2-15 listenv_0.7.0    digest_0.6.15    withr_2.1.2     
   [5] xtable_1.8-2     magrittr_1.5     bibtex_0.4.2     stringi_1.2.4   
   [9] tools_3.6.0      stringr_1.3.1    compiler_3.6.0   globals_0.12.1  
  - plan('sequential') ...
  plan(): nbrOfWorkers() = 1
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e023ef23f0> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 544 bytes (544 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = 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)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  NULL
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, local = TRUE, earlySignal = FALSE, 
                    label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    local <- as.logical(local)
                    future <- SequentialFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, local = local, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  Chunk #1 of 1 ... DONE
  Launching 1 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e02545e380> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 544 bytes (544 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  NULL
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, local = TRUE, earlySignal = FALSE, 
                    label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    local <- as.logical(local)
                    future <- SequentialFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, local = local, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  Chunk #1 of 1 ... DONE
  Launching 1 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  List of 2
   $ r1:List of 4
    ..$ : num 0.479
    ..$ : num 0.922
    ..$ : num 0.0592
    ..$ : num 0.191
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -305383241 69318028 -1161659107 -348804806 -1127582349 -343284712
    .. ..$ : int [1:7] 407 1222430165 -1386318120 1144759979 748500427 690571908 329037778
    .. ..$ : int [1:7] 407 215137210 -1421031558 1452323561 -2060097535 712279522 -278425444
    .. ..$ : int [1:7] 407 -1017432992 1583835527 1997665660 821136125 1282044776 1045008570
   $ r2:List of 4
    ..$ : num 0.479
    ..$ : num 0.922
    ..$ : num 0.0592
    ..$ : num 0.191
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -305383241 69318028 -1161659107 -348804806 -1127582349 -343284712
    .. ..$ : int [1:7] 407 1222430165 -1386318120 1144759979 748500427 690571908 329037778
    .. ..$ : int [1:7] 407 215137210 -1421031558 1452323561 -2060097535 712279522 -278425444
    .. ..$ : int [1:7] 407 -1017432992 1583835527 1997665660 821136125 1282044776 1045008570
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e02449f578> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 544 bytes (544 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  NULL
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, local = TRUE, earlySignal = FALSE, 
                    label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    local <- as.logical(local)
                    future <- SequentialFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, local = local, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  Chunk #1 of 1 ... DONE
  Launching 1 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  Warning in foreach(i = 1:4) %dorng% { :
    Foreach loop had changed the current RNG type: RNG was restored to same type, next state
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e023ac7310> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 544 bytes (544 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  NULL
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, local = TRUE, earlySignal = FALSE, 
                    label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    local <- as.logical(local)
                    future <- SequentialFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, local = local, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  Chunk #1 of 1 ... DONE
  Launching 1 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  Warning in foreach(i = 1:4) %dorng% { :
    Foreach loop had changed the current RNG type: RNG was restored to same type, next state
  List of 2
   $ s1:List of 4
    ..$ : num 0.479
    ..$ : num 0.922
    ..$ : num 0.0592
    ..$ : num 0.191
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -305383241 69318028 -1161659107 -348804806 -1127582349 -343284712
    .. ..$ : int [1:7] 407 1222430165 -1386318120 1144759979 748500427 690571908 329037778
    .. ..$ : int [1:7] 407 215137210 -1421031558 1452323561 -2060097535 712279522 -278425444
    .. ..$ : int [1:7] 407 -1017432992 1583835527 1997665660 821136125 1282044776 1045008570
   $ s2:List of 4
    ..$ : num 0.176
    ..$ : num 0.307
    ..$ : num 0.217
    ..$ : num 0.28
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -448109862 -965723501 -714383688 -1182650023 1528564038 1798437647
    .. ..$ : int [1:7] 407 1676527055 -47175865 -1376448368 1649226989 -706417026 817940116
    .. ..$ : int [1:7] 407 -619054052 -1236775269 1757470479 -426323619 -513425190 -1775510666
    .. ..$ : int [1:7] 407 1082473876 -724750406 -1303696142 48633096 1367296037 -341296503
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e024fa16b0> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 544 bytes (544 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  NULL
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, local = TRUE, earlySignal = FALSE, 
                    label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    local <- as.logical(local)
                    future <- SequentialFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, local = local, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  Chunk #1 of 1 ... DONE
  Launching 1 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  Warning in foreach(i = 1:4) %dorng% { :
    Foreach loop had changed the current RNG type: RNG was restored to same type, next state
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e0254b2470> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 544 bytes (544 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  NULL
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, local = TRUE, earlySignal = FALSE, 
                    label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    local <- as.logical(local)
                    future <- SequentialFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, local = local, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  Chunk #1 of 1 ... DONE
  Launching 1 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  Warning in foreach(i = 1:4) %dorng% { :
    Foreach loop had changed the current RNG type: RNG was restored to same type, next state
  List of 2
   $ s1_2:List of 4
    ..$ : num 0.479
    ..$ : num 0.922
    ..$ : num 0.0592
    ..$ : num 0.191
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -305383241 69318028 -1161659107 -348804806 -1127582349 -343284712
    .. ..$ : int [1:7] 407 1222430165 -1386318120 1144759979 748500427 690571908 329037778
    .. ..$ : int [1:7] 407 215137210 -1421031558 1452323561 -2060097535 712279522 -278425444
    .. ..$ : int [1:7] 407 -1017432992 1583835527 1997665660 821136125 1282044776 1045008570
   $ s2_2:List of 4
    ..$ : num 0.176
    ..$ : num 0.307
    ..$ : num 0.217
    ..$ : num 0.28
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -448109862 -965723501 -714383688 -1182650023 1528564038 1798437647
    .. ..$ : int [1:7] 407 1676527055 -47175865 -1376448368 1649226989 -706417026 817940116
    .. ..$ : int [1:7] 407 -619054052 -1236775269 1757470479 -426323619 -513425190 -1775510666
    .. ..$ : int [1:7] 407 1082473876 -724750406 -1303696142 48633096 1367296037 -341296503
  - plan('sequential') ... DONE
  - plan('multicore') ...
  plan(): nbrOfWorkers() = 2
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e0234f36b8> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = availableCores(constraints = "multicore"), 
                    earlySignal = FALSE, label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  plan(): nbrOfWorkers() = 1
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = availableCores(constraints = "multicore"), 
                    earlySignal = FALSE, label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e0250978f0> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = availableCores(constraints = "multicore"), 
                    earlySignal = FALSE, label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = availableCores(constraints = "multicore"), 
                    earlySignal = FALSE, label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
  plan(): nbrOfWorkers() = 1
   length: 2
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  List of 2
   $ r1:List of 4
    ..$ : num 0.479
    ..$ : num 0.922
    ..$ : num 0.0592
    ..$ : num 0.191
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -305383241 69318028 -1161659107 -348804806 -1127582349 -343284712
    .. ..$ : int [1:7] 407 1222430165 -1386318120 1144759979 748500427 690571908 329037778
    .. ..$ : int [1:7] 407 215137210 -1421031558 1452323561 -2060097535 712279522 -278425444
    .. ..$ : int [1:7] 407 -1017432992 1583835527 1997665660 821136125 1282044776 1045008570
   $ r2:List of 4
    ..$ : num 0.479
    ..$ : num 0.922
    ..$ : num 0.0592
    ..$ : num 0.191
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -305383241 69318028 -1161659107 -348804806 -1127582349 -343284712
    .. ..$ : int [1:7] 407 1222430165 -1386318120 1144759979 748500427 690571908 329037778
    .. ..$ : int [1:7] 407 215137210 -1421031558 1452323561 -2060097535 712279522 -278425444
    .. ..$ : int [1:7] 407 -1017432992 1583835527 1997665660 821136125 1282044776 1045008570
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e02423b088> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = availableCores(constraints = "multicore"), 
                    earlySignal = FALSE, label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  plan(): nbrOfWorkers() = 1
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = availableCores(constraints = "multicore"), 
                    earlySignal = FALSE, label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e0244cb708> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = availableCores(constraints = "multicore"), 
                    earlySignal = FALSE, label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = availableCores(constraints = "multicore"), 
                    earlySignal = FALSE, label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #2 of 2 ... DONE
  plan(): nbrOfWorkers() = 1
  Launching 2 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  List of 2
   $ s1:List of 4
    ..$ : num 0.479
    ..$ : num 0.922
    ..$ : num 0.0592
    ..$ : num 0.191
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -305383241 69318028 -1161659107 -348804806 -1127582349 -343284712
    .. ..$ : int [1:7] 407 1222430165 -1386318120 1144759979 748500427 690571908 329037778
    .. ..$ : int [1:7] 407 215137210 -1421031558 1452323561 -2060097535 712279522 -278425444
    .. ..$ : int [1:7] 407 -1017432992 1583835527 1997665660 821136125 1282044776 1045008570
   $ s2:List of 4
    ..$ : num 0.176
    ..$ : num 0.307
    ..$ : num 0.217
    ..$ : num 0.28
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -448109862 -965723501 -714383688 -1182650023 1528564038 1798437647
    .. ..$ : int [1:7] 407 1676527055 -47175865 -1376448368 1649226989 -706417026 817940116
    .. ..$ : int [1:7] 407 -619054052 -1236775269 1757470479 -426323619 -513425190 -1775510666
    .. ..$ : int [1:7] 407 1082473876 -724750406 -1303696142 48633096 1367296037 -341296503
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e0250b4140> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = availableCores(constraints = "multicore"), 
                    earlySignal = FALSE, label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  plan(): nbrOfWorkers() = 1
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = availableCores(constraints = "multicore"), 
                    earlySignal = FALSE, label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e024427998> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = availableCores(constraints = "multicore"), 
                    earlySignal = FALSE, label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  plan(): nbrOfWorkers() = 1
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = availableCores(constraints = "multicore"), 
                    earlySignal = FALSE, label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  List of 2
   $ s1_2:List of 4
    ..$ : num 0.479
    ..$ : num 0.922
    ..$ : num 0.0592
    ..$ : num 0.191
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -305383241 69318028 -1161659107 -348804806 -1127582349 -343284712
    .. ..$ : int [1:7] 407 1222430165 -1386318120 1144759979 748500427 690571908 329037778
    .. ..$ : int [1:7] 407 215137210 -1421031558 1452323561 -2060097535 712279522 -278425444
    .. ..$ : int [1:7] 407 -1017432992 1583835527 1997665660 821136125 1282044776 1045008570
   $ s2_2:List of 4
    ..$ : num 0.176
    ..$ : num 0.307
    ..$ : num 0.217
    ..$ : num 0.28
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -448109862 -965723501 -714383688 -1182650023 1528564038 1798437647
    .. ..$ : int [1:7] 407 1676527055 -47175865 -1376448368 1649226989 -706417026 817940116
    .. ..$ : int [1:7] 407 -619054052 -1236775269 1757470479 -426323619 -513425190 -1775510666
    .. ..$ : int [1:7] 407 1082473876 -724750406 -1303696142 48633096 1367296037 -341296503
  - plan('multicore') ... DONE
  - plan('multisession') ...
  plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  multisession:
  - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  - tweaked: FALSE
  - call: plan(strategy)
  Workers: [n = 2] 'localhost', 'localhost'
  Base port: 11609
  Creating node 1 of 2 ...
  - setting up node
  Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11609 OUT=/dev/null TIMEOUT=2592000 XDR=TRUE
  Waiting for worker #1 on 'localhost' to connect back
  Connection with worker #1 on 'localhost' established
  - assigning connection UUID
  - collecting session information
  Creating node 1 of 2 ... done
  Creating node 2 of 2 ...
  - setting up node
  Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11609 OUT=/dev/null TIMEOUT=2592000 XDR=TRUE
  Waiting for worker #2 on 'localhost' to connect back
  Connection with worker #2 on 'localhost' established
  - assigning connection UUID
  - collecting session information
  Creating node 2 of 2 ... done
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  ...future.mc.cores.old <- getOption("mc.cores")
                  options(mc.cores = 1L)
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local(NA)
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  MultisessionFuture started
  plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  plan(): nbrOfWorkers() = 2
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e0236e9328> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  Exporting 1 global objects (272 bytes) to cluster node #1 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #1 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #1 ... DONE
  Exporting 1 global objects (272 bytes) to cluster node #1 ... DONE
  MultisessionFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  Exporting 1 global objects (272 bytes) to cluster node #2 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #2 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #2 ... DONE
  Exporting 1 global objects (272 bytes) to cluster node #2 ... DONE
  MultisessionFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e024e92b00> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  Exporting 1 global objects (272 bytes) to cluster node #1 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #1 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #1 ... DONE
  Exporting 1 global objects (272 bytes) to cluster node #1 ... DONE
  MultisessionFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  Exporting 1 global objects (272 bytes) to cluster node #2 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #2 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #2 ... DONE
  Exporting 1 global objects (272 bytes) to cluster node #2 ... DONE
  MultisessionFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  List of 2
   $ r1:List of 4
    ..$ : num 0.479
    ..$ : num 0.922
    ..$ : num 0.0592
    ..$ : num 0.191
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -305383241 69318028 -1161659107 -348804806 -1127582349 -343284712
    .. ..$ : int [1:7] 407 1222430165 -1386318120 1144759979 748500427 690571908 329037778
    .. ..$ : int [1:7] 407 215137210 -1421031558 1452323561 -2060097535 712279522 -278425444
    .. ..$ : int [1:7] 407 -1017432992 1583835527 1997665660 821136125 1282044776 1045008570
   $ r2:List of 4
    ..$ : num 0.479
    ..$ : num 0.922
    ..$ : num 0.0592
    ..$ : num 0.191
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -305383241 69318028 -1161659107 -348804806 -1127582349 -343284712
    .. ..$ : int [1:7] 407 1222430165 -1386318120 1144759979 748500427 690571908 329037778
    .. ..$ : int [1:7] 407 215137210 -1421031558 1452323561 -2060097535 712279522 -278425444
    .. ..$ : int [1:7] 407 -1017432992 1583835527 1997665660 821136125 1282044776 1045008570
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e023ceba40> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  Exporting 1 global objects (272 bytes) to cluster node #1 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #1 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #1 ... DONE
  Exporting 1 global objects (272 bytes) to cluster node #1 ... DONE
  MultisessionFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  Exporting 1 global objects (272 bytes) to cluster node #2 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #2 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #2 ... DONE
  Exporting 1 global objects (272 bytes) to cluster node #2 ... DONE
  MultisessionFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e025607a10> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  Exporting 1 global objects (272 bytes) to cluster node #1 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #1 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #1 ... DONE
  Exporting 1 global objects (272 bytes) to cluster node #1 ... DONE
  MultisessionFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  Exporting 1 global objects (272 bytes) to cluster node #2 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #2 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #2 ... DONE
  Exporting 1 global objects (272 bytes) to cluster node #2 ... DONE
  MultisessionFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  List of 2
   $ s1:List of 4
    ..$ : num 0.479
    ..$ : num 0.922
    ..$ : num 0.0592
    ..$ : num 0.191
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -305383241 69318028 -1161659107 -348804806 -1127582349 -343284712
    .. ..$ : int [1:7] 407 1222430165 -1386318120 1144759979 748500427 690571908 329037778
    .. ..$ : int [1:7] 407 215137210 -1421031558 1452323561 -2060097535 712279522 -278425444
    .. ..$ : int [1:7] 407 -1017432992 1583835527 1997665660 821136125 1282044776 1045008570
   $ s2:List of 4
    ..$ : num 0.176
    ..$ : num 0.307
    ..$ : num 0.217
    ..$ : num 0.28
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -448109862 -965723501 -714383688 -1182650023 1528564038 1798437647
    .. ..$ : int [1:7] 407 1676527055 -47175865 -1376448368 1649226989 -706417026 817940116
    .. ..$ : int [1:7] 407 -619054052 -1236775269 1757470479 -426323619 -513425190 -1775510666
    .. ..$ : int [1:7] 407 1082473876 -724750406 -1303696142 48633096 1367296037 -341296503
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e024f762f0> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  Exporting 1 global objects (272 bytes) to cluster node #1 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #1 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #1 ... DONE
  Exporting 1 global objects (272 bytes) to cluster node #1 ... DONE
  MultisessionFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  Exporting 1 global objects (272 bytes) to cluster node #2 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #2 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #2 ... DONE
  Exporting 1 global objects (272 bytes) to cluster node #2 ... DONE
  MultisessionFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  doFuture() ...
  - dummy globals (as locals): [2] 'i', '.doRNG.stream'
  - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [16] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'library', 'runif', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
    - globals: [1] '...future.x_ii'
  List of 1
   $ ...future.x_ii: NULL
   - attr(*, "where")=List of 1
    ..$ ...future.x_ii:<environment: 0x55e02336af18> 
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 0
    - packages: [2] 'stats', 'doRNG'
    - R expression:
  {
      doFuture::registerDoFuture()
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              i <- NULL
              .doRNG.stream <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch({
              library("doRNG")
              {
                  {
                    rngtools::RNGseed(.doRNG.stream)
                  }
                  {
                    runif(1)
                  }
              }
          }, error = identity)
      })
  }
  - identifying globals and packages ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  Exporting 1 global objects (272 bytes) to cluster node #1 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #1 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #1 ... DONE
  Exporting 1 global objects (272 bytes) to cluster node #1 ... DONE
  MultisessionFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 272 bytes (272 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 2): 'stats', 'doRNG'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("stats", "doRNG")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              doFuture::registerDoFuture()
              lapply(seq_along(...future.x_ii), FUN = function(jj) {
                  ...future.x_jj <- ...future.x_ii[[jj]]
                  {
                    i <- NULL
                    .doRNG.stream <- NULL
                  }
                  ...future.env <- environment()
                  local({
                    for (name in names(...future.x_jj)) {
                      assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                        inherits = FALSE)
                    }
                  })
                  tryCatch({
                    library("doRNG")
                    {
                      {
                        rngtools::RNGseed(.doRNG.stream)
                      }
                      {
                        runif(1)
                      }
                    }
                  }, error = identity)
              })
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, persistent = FALSE, workers = availableCores(), 
                    gc = FALSE, earlySignal = FALSE, label = NULL, 
                    ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(length(workers) == 1, is.finite(workers), 
                      workers >= 1)
                    if (workers == 1L) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = TRUE, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    workers <- ClusterRegistry("start", workers = workers)
                    future <- MultisessionFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, persistent = persistent, 
                      workers = workers, gc = gc, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  Exporting 1 global objects (272 bytes) to cluster node #2 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #2 ...
  Exporting '...future.x_ii' (272 bytes) to cluster node #2 ... DONE
  Exporting 1 global objects (272 bytes) to cluster node #2 ... DONE
  MultisessionFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  - resolving future
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  - collecting values of future
  - accumulating results
  - processing errors (handler = 'stop')
  - extracting results
  doFuture() ... DONE
  List of 2
   $ s1_2:List of 4
    ..$ : num 0.479
    ..$ : num 0.922
    ..$ : num 0.0592
    ..$ : num 0.191
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -305383241 69318028 -1161659107 -348804806 -1127582349 -343284712
    .. ..$ : int [1:7] 407 1222430165 -1386318120 1144759979 748500427 690571908 329037778
    .. ..$ : int [1:7] 407 215137210 -1421031558 1452323561 -2060097535 712279522 -278425444
    .. ..$ : int [1:7] 407 -1017432992 1583835527 1997665660 821136125 1282044776 1045008570
   $ s2_2:List of 4
    ..$ : num 0.176
    ..$ : num 0.307
    ..$ : num 0.217
    ..$ : num 0.28
    ..- attr(*, "rng")=List of 4
    .. ..$ : int [1:7] 407 -448109862 -965723501 -714383688 -1182650023 1528564038 1798437647
    .. ..$ : int [1:7] 407 1676527055 -47175865 -1376448368 1649226989 -706417026 817940116
    .. ..$ : int [1:7] 407 -619054052 -1236775269 1757470479 -426323619 -513425190 -1775510666
    .. ..$ : int [1:7] 407 1082473876 -724750406 -1303696142 48633096 1367296037 -341296503
  - plan('multisession') ... DONE
  - plan('cluster') ...
  plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  cluster:
  - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  - tweaked: FALSE
  - call: plan(strategy)
  Workers: [n = 2] 'localhost', 'localhost'
  Base port: 11609
  Creating node 1 of 2 ...
  - setting up node
  Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11609 OUT=/dev/null TIMEOUT=2592000 XDR=TRUE
  Waiting for worker #1 on 'localhost' to connect back
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 11609 cannot be opened
  Error in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  : 
    cannot open the connection
  Calls: plan ... makeClusterPSOCK -> makeNode -> <Anonymous> -> socketConnection
  Execution halted