Running ‘fold.R’ [6s/7s]
  Running ‘future_apply.R’ [3s/6s]
  Running ‘future_eapply.R’ [1s/3s]
  Running ‘future_lapply,RNG.R’ [25s/74s]
  Running ‘future_lapply,globals.R’ [2s/8s]
  Running ‘future_lapply.R’ [7s/12s]
  Running ‘future_mapply,globals.R’ [2s/7s]
  Running ‘future_mapply.R’ [2s/3s]
  Running ‘future_replicate.R’ [2s/4s]
  Running ‘future_sapply.R’ [17s/27s]
  Running ‘future_tapply.R’ [1s/1s]
  Running ‘future_vapply.R’ [6s/12s]
  Running ‘globals,tricky_recursive.R’ [1s/3s]
  Running ‘rng.R’ [1s/1s]
  Running ‘utils.R’ [1s/1s]
Running the tests in ‘tests/future_mapply.R’ failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  
  Attaching package: 'future.apply'
  
  The following object is masked from 'package:future':
  
      future_lapply
  
  plan(): nbrOfWorkers() = 1
  > 
  > message("*** future_mapply() ...")
  *** future_mapply() ...
  > 
  > message("- Parallel RNG truth (for later)...")
  - Parallel RNG truth (for later)...
  > plan(sequential)
  plan(): nbrOfWorkers() = 1
  > y_rng_0 <- future_mapply(stats::runif, n = 1:4, max = 2:5,
  +                          MoreArgs = list(min = 1), future.seed = 0xBEEF)
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [3] 'FUN', '.Call', 'C_runif'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 1.98 KiB (2032 bytes)
  - globals: [1] 'FUN'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
   - needed namespaces: [1] 'stats'
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (n, min = 0, max = 1)  
   $ MoreArgs     :List of 1
    ..$ min: num 1
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x2f3e390> 
    ..$ MoreArgs     :<environment: R_EmptyEnv> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr "stats"
  Generating random seeds ...
  Generating random seed streams for 4 elements ...
  Generating random seed streams for 4 elements ... DONE
  Generating random seeds ... DONE
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 4 * 5.24288e+08 = 2.09715e+09 (bytes)
   - seeds: [4] <seeds>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 2.48 KiB (2536 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 1): 'stats'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = 2097152000, 
              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 "stats") {
                      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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
                  assign(".Random.seed", ...future.seeds_ii_jj, 
                    envir = globalenv(), inherits = FALSE)
                  ...future.FUN(...)
              }
              args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
                  list(...future.seeds_ii_jj = ...future.seeds_ii), 
                  MoreArgs, SIMPLIFY = FALSE, USE.NAMES = FALSE)
              do.call(mapply, args = args)
          })
          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 1 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
   - Number of value chunks collected: 1
  Resolving 1 futures (chunks) ... DONE
  Reducing values from 1 chunks ...
   - Number of values collected after concatenation: 4
   - Number of values expected: 4
  Reducing values from 1 chunks ... DONE
  future_mapply() ... DONE
  > print(y_rng_0)
  [[1]]
  [1] 1.752502
  
  [[2]]
  [1] 2.765950 2.044156
  
  [[3]]
  [1] 1.419503 3.529684 1.023802
  
  [[4]]
  [1] 4.494280 3.546145 1.402837 4.295444
  
  > 
  > for (strategy in supportedStrategies()) {
  +   message(sprintf("*** strategy = %s ...", sQuote(strategy)))
  +   plan(strategy)
  + 
  +   message("- From example(mapply) ...")
  +   y0 <- mapply(rep, 1:4, 4:1)
  +   y1 <- future_mapply(rep, 1:4, 4:1)
  +   stopifnot(identical(y1, y0))
  +   
  +   y0 <- mapply(rep, times = 1:4, x = 4:1)
  +   y1 <- future_mapply(rep, times = 1:4, x = 4:1)
  +   stopifnot(identical(y1, y0))
  +   
  +   y0 <- mapply(rep, times = 1:4, MoreArgs = list(x = 42))
  +   y1 <- future_mapply(rep, times = 1:4, MoreArgs = list(x = 42))
  +   stopifnot(identical(y1, y0))
  +   
  +   y0 <- mapply(function(x, y) seq_len(x) + y,
  +                c(a =  1, b = 2, c = 3),  # names from first
  +                c(A = 10, B = 0, C = -10))
  +   y1 <- future_mapply(function(x, y) seq_len(x) + y,
  +                       c(a =  1, b = 2, c = 3),  # names from first
  +                       c(A = 10, B = 0, C = -10))
  +   stopifnot(identical(y1, y0))
  +   
  +   word <- function(C, k) paste(rep.int(C, k), collapse = "")
  +   y0 <- mapply(word, LETTERS[1:6], 6:1, SIMPLIFY = FALSE)
  +   y1 <- future_mapply(word, LETTERS[1:6], 6:1, SIMPLIFY = FALSE)
  +   stopifnot(identical(y1, y0))
  + 
  + 
  +   message("- Subsetting (Issue #17) ...")
  +   X <- as.Date("2018-06-01")
  +   y0 <- mapply(FUN = identity, X, SIMPLIFY = FALSE)
  +   y1 <- future_mapply(FUN = identity, X, SIMPLIFY = FALSE)
  +   stopifnot(identical(y1, y0))
  +   
  +   message("- Recycle arguments to same length ...")
  +   y0 <- mapply(rep, 1:4, 2:1)
  +   y1 <- future_mapply(rep, 1:4, 2:1)
  +   stopifnot(identical(y1, y0))
  + 
  +   
  +   message("- Parallel RNG ...")
  +   y_rng_1 <- future_mapply(stats::runif, n = 1:4, max = 2:5,
  +                            MoreArgs = list(min = 1), future.seed = 0xBEEF)
  +   print(y_rng_1)
  +   stopifnot(all.equal(y_rng_1, y_rng_0))
  + 
  +   
  +   message("- future_Map() ...")
  +   xs <- replicate(5, stats::runif(10), simplify = FALSE)
  +   ws <- replicate(5, stats::rpois(10, 5) + 1, simplify = FALSE)
  +   y0 <- Map(weighted.mean, xs, ws)
  +   y1 <- future_Map(stats::weighted.mean, xs, ws)
  +   stopifnot(all.equal(y1, y0))
  +   
  +   plan(sequential)
  +   message(sprintf("*** strategy = %s ... done", sQuote(strategy)))
  + } ## for (strategy in ...) 
  *** strategy = 'sequential' ...
  plan(): nbrOfWorkers() = 1
  - From example(mapply) ...
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [1] 'FUN'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 56 bytes (56 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x3166b80> 
    ..$ MoreArgs     :<environment: 0x3288790> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 4 * 5.24288e+08 = 2.09715e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 184 bytes (184 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 2097152000, 
              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::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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 1 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
   - Number of value chunks collected: 1
  Resolving 1 futures (chunks) ... DONE
  Reducing values from 1 chunks ...
   - Number of values collected after concatenation: 4
   - Number of values expected: 4
  Reducing values from 1 chunks ... DONE
  future_mapply() ... DONE
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [1] 'FUN'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 56 bytes (56 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0xffa378> 
    ..$ MoreArgs     :<environment: 0x168c7b8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 4 * 5.24288e+08 = 2.09715e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 184 bytes (184 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 2097152000, 
              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::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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 1 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
   - Number of value chunks collected: 1
  Resolving 1 futures (chunks) ... DONE
  Reducing values from 1 chunks ...
   - Number of values collected after concatenation: 4
   - Number of values expected: 4
  Reducing values from 1 chunks ... DONE
  future_mapply() ... DONE
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [1] 'FUN'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 56 bytes (56 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ MoreArgs     :List of 1
    ..$ x: num 42
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x2cc2d68> 
    ..$ MoreArgs     :<environment: R_EmptyEnv> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 4 * 5.24288e+08 = 2.09715e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 176 bytes (176 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 2097152000, 
              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::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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 1 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
   - Number of value chunks collected: 1
  Resolving 1 futures (chunks) ... DONE
  Reducing values from 1 chunks ...
   - Number of values collected after concatenation: 4
   - Number of values expected: 4
  Reducing values from 1 chunks ... DONE
  future_mapply() ... DONE
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [3] 'FUN', '+', 'seq_len'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 1.88 KiB (1920 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x1fa1f08> 
    ..$ MoreArgs     :<environment: 0x173cf68> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 3 * 5.24288e+08 = 1.57286e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 2.73 KiB (2800 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1572864000, 
              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::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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 1 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
   - Number of value chunks collected: 1
  Resolving 1 futures (chunks) ... DONE
  Reducing values from 1 chunks ...
   - Number of values collected after concatenation: 3
   - Number of values expected: 3
  Reducing values from 1 chunks ... DONE
  future_mapply() ... DONE
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [3] 'FUN', 'paste', 'rep.int'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 3.13 KiB (3208 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (C, k)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x2a6b018> 
    ..$ MoreArgs     :<environment: 0x2bc0d88> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 6 * 5.24288e+08 = 3.14573e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 3.63 KiB (3720 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 3145728000, 
              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::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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 1 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
   - Number of value chunks collected: 1
  Resolving 1 futures (chunks) ... DONE
  Reducing values from 1 chunks ...
   - Number of values collected after concatenation: 6
   - Number of values expected: 6
  Reducing values from 1 chunks ... DONE
  future_mapply() ... DONE
  - Subsetting (Issue #17) ...
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [1] 'FUN'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 792 bytes (792 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x324f230> 
    ..$ MoreArgs     :<environment: 0x33d3400> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 1.05 KiB (1072 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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::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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 1 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
   - Number of value chunks collected: 1
  Resolving 1 futures (chunks) ... DONE
  Reducing values from 1 chunks ...
   - Number of values collected after concatenation: 1
   - Number of values expected: 1
  Reducing values from 1 chunks ... DONE
  future_mapply() ... DONE
  - Recycle arguments to same length ...
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [1] 'FUN'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 56 bytes (56 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x16aeaf0> 
    ..$ MoreArgs     :<environment: 0x1fff730> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 4 * 5.24288e+08 = 2.09715e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 184 bytes (184 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 2097152000, 
              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::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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 1 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
   - Number of value chunks collected: 1
  Resolving 1 futures (chunks) ... DONE
  Reducing values from 1 chunks ...
   - Number of values collected after concatenation: 4
   - Number of values expected: 4
  Reducing values from 1 chunks ... DONE
  future_mapply() ... DONE
  - Parallel RNG ...
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [3] 'FUN', '.Call', 'C_runif'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 1.98 KiB (2032 bytes)
  - globals: [1] 'FUN'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
   - needed namespaces: [1] 'stats'
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (n, min = 0, max = 1)  
   $ MoreArgs     :List of 1
    ..$ min: num 1
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x2ea0420> 
    ..$ MoreArgs     :<environment: R_EmptyEnv> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr "stats"
  Generating random seeds ...
  Generating random seed streams for 4 elements ...
  Generating random seed streams for 4 elements ... DONE
  Generating random seeds ... DONE
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 4 * 5.24288e+08 = 2.09715e+09 (bytes)
   - seeds: [4] <seeds>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 2.48 KiB (2536 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 1): 'stats'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = 2097152000, 
              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 "stats") {
                      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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
                  assign(".Random.seed", ...future.seeds_ii_jj, 
                    envir = globalenv(), inherits = FALSE)
                  ...future.FUN(...)
              }
              args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
                  list(...future.seeds_ii_jj = ...future.seeds_ii), 
                  MoreArgs, SIMPLIFY = FALSE, USE.NAMES = FALSE)
              do.call(mapply, args = args)
          })
          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 1 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
   - Number of value chunks collected: 1
  Resolving 1 futures (chunks) ... DONE
  Reducing values from 1 chunks ...
   - Number of values collected after concatenation: 4
   - Number of values expected: 4
  Reducing values from 1 chunks ... DONE
  future_mapply() ... DONE
  [[1]]
  [1] 1.752502
  
  [[2]]
  [1] 2.765950 2.044156
  
  [[3]]
  [1] 1.419503 3.529684 1.023802
  
  [[4]]
  [1] 4.494280 3.546145 1.402837 4.295444
  
  - future_Map() ...
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [2] 'FUN', 'UseMethod'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 1.33 KiB (1360 bytes)
  - globals: [1] 'FUN'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
   - needed namespaces: [1] 'stats'
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, w, ...)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x12e0ad0> 
    ..$ MoreArgs     :<environment: 0x1470520> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr "stats"
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 5 * 5.24288e+08 = 2.62144e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 3.05 KiB (3120 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 1): 'stats'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = 2621440000, 
              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 "stats") {
                      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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 1 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
   - Number of value chunks collected: 1
  Resolving 1 futures (chunks) ... DONE
  Reducing values from 1 chunks ...
   - Number of values collected after concatenation: 5
   - Number of values expected: 5
  Reducing values from 1 chunks ... DONE
  future_mapply() ... DONE
  plan(): nbrOfWorkers() = 1
  *** strategy = 'sequential' ... done
  *** strategy = 'multicore' ...
  plan(): nbrOfWorkers() = 2
  - From example(mapply) ...
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [1] 'FUN'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 56 bytes (56 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x2f8bf98> 
    ..$ MoreArgs     :<environment: 0x30f2760> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 168 bytes (168 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1048576000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 168 bytes (168 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1048576000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 2 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 2
  
  plan(): nbrOfWorkers() = 1
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
   - Number of value chunks collected: 2
  Resolving 2 futures (chunks) ... DONE
  Reducing values from 2 chunks ...
   - Number of values collected after concatenation: 4
   - Number of values expected: 4
  Reducing values from 2 chunks ... DONE
  future_mapply() ... DONE
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [1] 'FUN'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 56 bytes (56 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x2aa7610> 
    ..$ MoreArgs     :<environment: 0x2b9fe98> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 168 bytes (168 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1048576000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  plan(): nbrOfWorkers() = 1
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 168 bytes (168 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1048576000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 2 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
   - Number of value chunks collected: 2
  Resolving 2 futures (chunks) ... DONE
  Reducing values from 2 chunks ...
   - Number of values collected after concatenation: 4
   - Number of values expected: 4
  Reducing values from 2 chunks ... DONE
  future_mapply() ... DONE
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [1] 'FUN'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 56 bytes (56 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ MoreArgs     :List of 1
    ..$ x: num 42
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x1976ba0> 
    ..$ MoreArgs     :<environment: R_EmptyEnv> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 168 bytes (168 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1048576000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 168 bytes (168 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1048576000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 = {
          {
              {
  plan(): nbrOfWorkers() = 1
                  {
                    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 2 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
   - Number of value chunks collected: 2
  Resolving 2 futures (chunks) ... DONE
  Reducing values from 2 chunks ...
   - Number of values collected after concatenation: 4
   - Number of values expected: 4
  Reducing values from 2 chunks ... DONE
  future_mapply() ... DONE
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [3] 'FUN', '+', 'seq_len'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 1.88 KiB (1920 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x2f06ad8> 
    ..$ MoreArgs     :<environment: 0x3121948> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 2.42 KiB (2480 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 2.56 KiB (2624 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1048576000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 2 futures (chunks) ...
  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
   - Number of value chunks collected: 2
  Resolving 2 futures (chunks) ... DONE
  Reducing values from 2 chunks ...
   - Number of values collected after concatenation: 3
   - Number of values expected: 3
  Reducing values from 2 chunks ... DONE
  future_mapply() ... DONE
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [3] 'FUN', 'paste', 'rep.int'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 3.13 KiB (3208 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (C, k)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x15e4228> 
    ..$ MoreArgs     :<environment: 0x2aea460> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 3 * 5.24288e+08 = 1.57286e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 3.44 KiB (3520 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1572864000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 3 * 5.24288e+08 = 1.57286e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 3.44 KiB (3520 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1572864000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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, 
  plan(): nbrOfWorkers() = 1
                        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 2 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
   - Number of value chunks collected: 2
  Resolving 2 futures (chunks) ... DONE
  Reducing values from 2 chunks ...
   - Number of values collected after concatenation: 6
   - Number of values expected: 6
  Reducing values from 2 chunks ... DONE
  future_mapply() ... DONE
  - Subsetting (Issue #17) ...
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [1] 'FUN'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 792 bytes (792 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x1b6ae70> 
    ..$ MoreArgs     :<environment: 0x14443b8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 1
  Number of futures (= number of chunks): 1
  Launching 1 futures (chunks) ...
  Chunk #1 of 1 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 1.05 KiB (1072 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 1 ... DONE
  Launching 1 futures (chunks) ... DONE
  Resolving 1 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 1
  
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 1)
  resolve() on list ... DONE
   - Number of value chunks collected: 1
  Resolving 1 futures (chunks) ... DONE
  Reducing values from 1 chunks ...
   - Number of values collected after concatenation: 1
   - Number of values expected: 1
  Reducing values from 1 chunks ... DONE
  future_mapply() ... DONE
  - Recycle arguments to same length ...
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [1] 'FUN'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 56 bytes (56 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x2b28a20> 
    ..$ MoreArgs     :<environment: 0x2c64a38> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 168 bytes (168 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1048576000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 168 bytes (168 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... DONE
  plan(): nbrOfWorkers() = 1
  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 = 1048576000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 2 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
   - Number of value chunks collected: 2
  Resolving 2 futures (chunks) ... DONE
  Reducing values from 2 chunks ...
   - Number of values collected after concatenation: 4
   - Number of values expected: 4
  Reducing values from 2 chunks ... DONE
  future_mapply() ... DONE
  - Parallel RNG ...
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [3] 'FUN', '.Call', 'C_runif'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 1.98 KiB (2032 bytes)
  - globals: [1] 'FUN'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
   - needed namespaces: [1] 'stats'
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (n, min = 0, max = 1)  
   $ MoreArgs     :List of 1
    ..$ min: num 1
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x1464e10> 
    ..$ MoreArgs     :<environment: R_EmptyEnv> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr "stats"
  Generating random seeds ...
  Generating random seed streams for 4 elements ...
  Generating random seed streams for 4 elements ... DONE
  Generating random seeds ... DONE
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: [2] <seeds>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 2.30 KiB (2360 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 1): 'stats'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = 1048576000, 
              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 "stats") {
                      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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
                  assign(".Random.seed", ...future.seeds_ii_jj, 
                    envir = globalenv(), inherits = FALSE)
                  ...future.FUN(...)
              }
              args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
                  list(...future.seeds_ii_jj = ...future.seeds_ii), 
                  MoreArgs, SIMPLIFY = FALSE, USE.NAMES = FALSE)
              do.call(mapply, args = args)
          })
          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() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: [2] <seeds>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 2.30 KiB (2360 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 1): 'stats'
  plan(): nbrOfWorkers() = 1
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = 1048576000, 
              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 "stats") {
                      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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              ...future.FUN2 <- function(..., ...future.seeds_ii_jj) {
                  assign(".Random.seed", ...future.seeds_ii_jj, 
                    envir = globalenv(), inherits = FALSE)
                  ...future.FUN(...)
              }
              args <- c(list(FUN = ...future.FUN2), ...future.elements_ii, 
                  list(...future.seeds_ii_jj = ...future.seeds_ii), 
                  MoreArgs, SIMPLIFY = FALSE, USE.NAMES = FALSE)
              do.call(mapply, args = args)
          })
          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 2 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
   - Number of value chunks collected: 2
  Resolving 2 futures (chunks) ... DONE
  Reducing values from 2 chunks ...
   - Number of values collected after concatenation: 4
   - Number of values expected: 4
  Reducing values from 2 chunks ... DONE
  future_mapply() ... DONE
  [[1]]
  [1] 1.752502
  
  [[2]]
  [1] 2.765950 2.044156
  
  [[3]]
  [1] 1.419503 3.529684 1.023802
  
  [[4]]
  [1] 4.494280 3.546145 1.402837 4.295444
  
  - future_Map() ...
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [2] 'FUN', 'UseMethod'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 1.33 KiB (1360 bytes)
  - globals: [1] 'FUN'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
   - needed namespaces: [1] 'stats'
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, w, ...)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x316f760> 
    ..$ MoreArgs     :<environment: 0x33478a8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr "stats"
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 2.02 KiB (2064 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 1): 'stats'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = 1048576000, 
              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 "stats") {
                      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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 3 * 5.24288e+08 = 1.57286e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 2.36 KiB (2416 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  - packages: [1] 'stats'
  getGlobalsAndPackages() ... DONE
  plan(): nbrOfWorkers() = 1
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 1): 'stats'
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = 1572864000, 
              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 "stats") {
                      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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 2 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 1
   length: 0 (resolved future 2)
  resolve() on list ... DONE
   - Number of value chunks collected: 2
  Resolving 2 futures (chunks) ... DONE
  Reducing values from 2 chunks ...
   - Number of values collected after concatenation: 5
   - Number of values expected: 5
  Reducing values from 2 chunks ... DONE
  future_mapply() ... DONE
  plan(): nbrOfWorkers() = 1
  *** strategy = 'multicore' ... done
  *** strategy = '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: 11078
  Creating node 1 of 2 ...
  - setting up node
  Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11078 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-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11078 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
  - From example(mapply) ...
  future_mapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [1] 'FUN'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 56 bytes (56 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ MoreArgs     : NULL
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x30ab6c0> 
    ..$ MoreArgs     :<environment: 0x3188138> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num NA
  Packages to be attached in all futures:
   chr(0) 
  Number of chunks: 2
  Number of futures (= number of chunks): 2
  Launching 2 futures (chunks) ...
  Chunk #1 of 2 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 168 bytes (168 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1048576000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 5 global objects (168 bytes) to cluster node #1 ...
  Exporting '...future.FUN' (56 bytes) to cluster node #1 ...
  Exporting '...future.FUN' (56 bytes) to cluster node #1 ... DONE
  Exporting 'MoreArgs' (0 bytes) to cluster node #1 ...
  Exporting 'MoreArgs' (0 bytes) to cluster node #1 ... DONE
  Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
  Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
  Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
  Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
  Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
  Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
  Exporting 5 global objects (168 bytes) to cluster node #1 ... DONE
  MultisessionFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
  getGlobalsAndPackages() ...
  Searching for globals ...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  The total size of the 5 globals is 168 bytes (168 bytes)
  - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... 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 = 1048576000, 
              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({
              ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
              if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
                  oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
                  on.exit(options(oopts), add = TRUE)
              }
              args <- c(list(FUN = ...future.FUN), ...future.elements_ii, 
                  MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, 
                  USE.NAMES = FALSE)
              res <- do.call(mapply, args = args)
              res
          })
          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 5 global objects (168 bytes) to cluster node #2 ...
  Exporting '...future.FUN' (56 bytes) to cluster node #2 ...
  Exporting '...future.FUN' (56 bytes) to cluster node #2 ... DONE
  Exporting 'MoreArgs' (0 bytes) to cluster node #2 ...
  Exporting 'MoreArgs' (0 bytes) to cluster node #2 ... DONE
  Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ...
  Exporting '...future.elements_ii' (112 bytes) to cluster node #2 ... DONE
  Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ...
  Exporting '...future.seeds_ii' (0 bytes) to cluster node #2 ... DONE
  Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ...
  Exporting '...future.globals.maxSize' (0 bytes) to cluster node #2 ... DONE
  Exporting 5 global objects (168 bytes) to cluster node #2 ... DONE
  MultisessionFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  Resolving 2 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  Error: Unexpected result (of class 'snow-try-error' != 'FutureResult') retrieved for MultisessionFuture future (label = '<none>', expression = '{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; res <- do.call(mapply, args = args); res; }'): Package 'future' is not installed on worker (r_version: R Under development (unstable) (2018-10-09 r75424); platform: x86_64-pc-linux-gnu (64-bit); os: Linux 4.16.0-2-amd64 #1 SMP Debian 4.16.12-1 (2018-05-27); hostname: gimli)
  Execution halted