Running ‘fold.R’ [5s/7s]
  Running ‘future_apply.R’ [3s/8s]
  Running ‘future_eapply.R’ [2s/6s]
  Running ‘future_lapply,RNG.R’ [27s/71s]
  Running ‘future_lapply,globals.R’ [2s/10s]
  Running ‘future_lapply.R’ [9s/21s]
  Running ‘future_mapply,globals.R’ [2s/8s]
  Running ‘future_mapply.R’ [4s/9s]
  Running ‘future_replicate.R’ [2s/7s]
  Running ‘future_sapply.R’ [11s/21s]
  Running ‘future_tapply.R’ [1s/2s]
  Running ‘future_vapply.R’ [6s/15s]
  Running ‘globals,tricky_recursive.R’ [1s/5s]
  Running ‘rng.R’ [0s/1s]
  Running ‘stdout.R’ [2s/21s]
  Running ‘utils.R’ [0s/1s]
Running the tests in ‘tests/future_sapply.R’ failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: future::plan("sequential")
  
  plan(): nbrOfWorkers() = 1
  > 
  > message("*** future_sapply() ...")
  *** future_sapply() ...
  > 
  > xs <- list(
  +   A = c(a = 1, b = 2, c = 3),
  +   B = c(a = 1:2, b = 2:3, c = 3:4),
  +   C = letters[1:3],
  +   D = structure(10 * 5:8, names = LETTERS[1:4])
  + )
  > 
  > FUNS <- list(
  +   a = identity,
  +   b = as.matrix,
  +   c = function(x, y = 2 * 1:5) outer(rep(x, length.out = 3L), y)
  + )
  > 
  > for (strategy in supportedStrategies()) {
  +   message(sprintf("*** strategy = %s ...", sQuote(strategy)))
  +   plan(strategy)
  +   
  +   for (x in xs) {
  +     FUNS_x <- FUNS
  +     if (!is.numeric(x)) FUNS_x[["c"]] <- NULL
  +     
  +     for (USE.NAMES in list(FALSE, TRUE)) {
  +       for (simplify in list(FALSE, TRUE, "array")) {
  +         for (FUN in FUNS_x) {
  +           y0 <-        sapply(x, FUN = FUN,
  +                               USE.NAMES = USE.NAMES, simplify = simplify)
  +           y1 <- future_sapply(x, FUN = FUN,
  +                               USE.NAMES = USE.NAMES, simplify = simplify)
  +           str(list(y0 = y0, y1 = y1))
  +           stopifnot(identical(y1, y0))
  +           if (identical(simplify, FALSE)) {
  +              y2 <- lapply(x, FUN = FUN)
  +              str(list(y0 = y0, y2 = y2))
  +              stopifnot(identical(unname(y2), unname(y0)))
  +           }
  +         }
  +       }
  +     }
  +   }
  +   
  +   plan(sequential)
  +   message(sprintf("*** strategy = %s ... done", sQuote(strategy)))
  + } ## for (strategy in ...) 
  *** strategy = 'sequential' ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 1
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2a9383f0> 
    ..$ ...          :<environment: 0x55ca2a9383f0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.26 KiB (1288 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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 = 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)
                  }
              }
              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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
   $ y1:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
  List of 2
   $ y0:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
   $ y2:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2a725870> 
    ..$ ...          :<environment: 0x55ca2a725870> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.65 KiB (1688 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
   $ y1:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
  List of 2
   $ y0:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
   $ y2:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2a794b10> 
    ..$ ...          :<environment: 0x55ca2a794b10> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.05 KiB (5168 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
   $ y1:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  List of 2
   $ y0:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
   $ y2:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29ae7348> 
    ..$ ...          :<environment: 0x55ca29ae7348> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.26 KiB (1288 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2974ce48> 
    ..$ ...          :<environment: 0x55ca2974ce48> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.65 KiB (1688 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2adf79d0> 
    ..$ ...          :<environment: 0x55ca2adf79d0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.05 KiB (5168 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
   $ y1: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2a901910> 
    ..$ ...          :<environment: 0x55ca2a901910> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.26 KiB (1288 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca28c59c30> 
    ..$ ...          :<environment: 0x55ca28c59c30> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.65 KiB (1688 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2b2a5188> 
    ..$ ...          :<environment: 0x55ca2b2a5188> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.05 KiB (5168 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
   $ y1: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2ad3c8b0> 
    ..$ ...          :<environment: 0x55ca2ad3c8b0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.26 KiB (1288 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
   $ y1:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
  List of 2
   $ y0:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
   $ y2:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2ab26278> 
    ..$ ...          :<environment: 0x55ca2ab26278> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.65 KiB (1688 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
   $ y1:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
  List of 2
   $ y0:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
   $ y2:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2a8c1250> 
    ..$ ...          :<environment: 0x55ca2a8c1250> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.05 KiB (5168 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
   $ y1:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  List of 2
   $ y0:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
   $ y2:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2a7a1500> 
    ..$ ...          :<environment: 0x55ca2a7a1500> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.26 KiB (1288 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29103870> 
    ..$ ...          :<environment: 0x55ca29103870> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.65 KiB (1688 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2afbf1c8> 
    ..$ ...          :<environment: 0x55ca2afbf1c8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.05 KiB (5168 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
   $ y1: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2ac401e0> 
    ..$ ...          :<environment: 0x55ca2ac401e0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.26 KiB (1288 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca290d3198> 
    ..$ ...          :<environment: 0x55ca290d3198> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.65 KiB (1688 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca296d2920> 
    ..$ ...          :<environment: 0x55ca296d2920> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.05 KiB (5168 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
   $ y1: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2b022650> 
    ..$ ...          :<environment: 0x55ca2b022650> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.44 KiB (1472 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 6
    ..$ a1: int 1
    ..$ a2: int 2
    ..$ b1: int 2
    ..$ b2: int 3
    ..$ c1: int 3
    ..$ c2: int 4
   $ y1:List of 6
    ..$ a1: int 1
    ..$ a2: int 2
    ..$ b1: int 2
    ..$ b2: int 3
    ..$ c1: int 3
    ..$ c2: int 4
  List of 2
   $ y0:List of 6
    ..$ a1: int 1
    ..$ a2: int 2
    ..$ b1: int 2
    ..$ b2: int 3
    ..$ c1: int 3
    ..$ c2: int 4
   $ y2:List of 6
    ..$ a1: int 1
    ..$ a2: int 2
    ..$ b1: int 2
    ..$ b2: int 3
    ..$ c1: int 3
    ..$ c2: int 4
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29bd2240> 
    ..$ ...          :<environment: 0x55ca29bd2240> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.83 KiB (1872 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 6
    ..$ a1: int [1, 1] 1
    ..$ a2: int [1, 1] 2
    ..$ b1: int [1, 1] 2
    ..$ b2: int [1, 1] 3
    ..$ c1: int [1, 1] 3
    ..$ c2: int [1, 1] 4
   $ y1:List of 6
    ..$ a1: int [1, 1] 1
    ..$ a2: int [1, 1] 2
    ..$ b1: int [1, 1] 2
    ..$ b2: int [1, 1] 3
    ..$ c1: int [1, 1] 3
    ..$ c2: int [1, 1] 4
  List of 2
   $ y0:List of 6
    ..$ a1: int [1, 1] 1
    ..$ a2: int [1, 1] 2
    ..$ b1: int [1, 1] 2
    ..$ b2: int [1, 1] 3
    ..$ c1: int [1, 1] 3
    ..$ c2: int [1, 1] 4
   $ y2:List of 6
    ..$ a1: int [1, 1] 1
    ..$ a2: int [1, 1] 2
    ..$ b1: int [1, 1] 2
    ..$ b2: int [1, 1] 3
    ..$ c1: int [1, 1] 3
    ..$ c2: int [1, 1] 4
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca290a95d8> 
    ..$ ...          :<environment: 0x55ca290a95d8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.23 KiB (5352 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 6
    ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
   $ y1:List of 6
    ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
  List of 2
   $ y0:List of 6
    ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
   $ y2:List of 6
    ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca295b1ec8> 
    ..$ ...          :<environment: 0x55ca295b1ec8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.44 KiB (1472 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
   $ y1: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29c54488> 
    ..$ ...          :<environment: 0x55ca29c54488> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.83 KiB (1872 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
   $ y1: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2ad3ff48> 
    ..$ ...          :<environment: 0x55ca2ad3ff48> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.23 KiB (5352 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: num [1:15, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
   $ y1: num [1:15, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2a731250> 
    ..$ ...          :<environment: 0x55ca2a731250> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.44 KiB (1472 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
   $ y1: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca296a6b18> 
    ..$ ...          :<environment: 0x55ca296a6b18> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.83 KiB (1872 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
   $ y1: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2ae7d638> 
    ..$ ...          :<environment: 0x55ca2ae7d638> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.23 KiB (5352 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: num [1:3, 1:5, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
   $ y1: num [1:3, 1:5, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2aa29b70> 
    ..$ ...          :<environment: 0x55ca2aa29b70> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.44 KiB (1472 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 6
    ..$ a1: int 1
    ..$ a2: int 2
    ..$ b1: int 2
    ..$ b2: int 3
    ..$ c1: int 3
    ..$ c2: int 4
   $ y1:List of 6
    ..$ a1: int 1
    ..$ a2: int 2
    ..$ b1: int 2
    ..$ b2: int 3
    ..$ c1: int 3
    ..$ c2: int 4
  List of 2
   $ y0:List of 6
    ..$ a1: int 1
    ..$ a2: int 2
    ..$ b1: int 2
    ..$ b2: int 3
    ..$ c1: int 3
    ..$ c2: int 4
   $ y2:List of 6
    ..$ a1: int 1
    ..$ a2: int 2
    ..$ b1: int 2
    ..$ b2: int 3
    ..$ c1: int 3
    ..$ c2: int 4
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2ab8ad90> 
    ..$ ...          :<environment: 0x55ca2ab8ad90> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.83 KiB (1872 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 6
    ..$ a1: int [1, 1] 1
    ..$ a2: int [1, 1] 2
    ..$ b1: int [1, 1] 2
    ..$ b2: int [1, 1] 3
    ..$ c1: int [1, 1] 3
    ..$ c2: int [1, 1] 4
   $ y1:List of 6
    ..$ a1: int [1, 1] 1
    ..$ a2: int [1, 1] 2
    ..$ b1: int [1, 1] 2
    ..$ b2: int [1, 1] 3
    ..$ c1: int [1, 1] 3
    ..$ c2: int [1, 1] 4
  List of 2
   $ y0:List of 6
    ..$ a1: int [1, 1] 1
    ..$ a2: int [1, 1] 2
    ..$ b1: int [1, 1] 2
    ..$ b2: int [1, 1] 3
    ..$ c1: int [1, 1] 3
    ..$ c2: int [1, 1] 4
   $ y2:List of 6
    ..$ a1: int [1, 1] 1
    ..$ a2: int [1, 1] 2
    ..$ b1: int [1, 1] 2
    ..$ b2: int [1, 1] 3
    ..$ c1: int [1, 1] 3
    ..$ c2: int [1, 1] 4
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2ad455e8> 
    ..$ ...          :<environment: 0x55ca2ad455e8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.23 KiB (5352 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 6
    ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
   $ y1:List of 6
    ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
  List of 2
   $ y0:List of 6
    ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
   $ y2:List of 6
    ..$ a1: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ a2: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b1: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ b2: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c1: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
    ..$ c2: num [1:3, 1:5] 8 8 8 16 16 16 24 24 24 32 ...
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2af5c788> 
    ..$ ...          :<environment: 0x55ca2af5c788> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.44 KiB (1472 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
   $ y1: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2a8950e8> 
    ..$ ...          :<environment: 0x55ca2a8950e8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.83 KiB (1872 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
   $ y1: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca28cfc778> 
    ..$ ...          :<environment: 0x55ca28cfc778> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.23 KiB (5352 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: num [1:15, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
   $ y1: num [1:15, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2b0ac750> 
    ..$ ...          :<environment: 0x55ca2b0ac750> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.44 KiB (1472 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
   $ y1: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2abc74c8> 
    ..$ ...          :<environment: 0x55ca2abc74c8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.83 KiB (1872 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
   $ y1: Named int [1:6] 1 2 2 3 3 4
    ..- attr(*, "names")= chr [1:6] "a1" "a2" "b1" "b2" ...
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca28d3d548> 
    ..$ ...          :<environment: 0x55ca28d3d548> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.23 KiB (5352 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: num [1:3, 1:5, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
   $ y1: num [1:3, 1:5, 1:6] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:6] "a1" "a2" "b1" "b2" ...
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca293ca7e8> 
    ..$ ...          :<environment: 0x55ca293ca7e8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.07 KiB (1096 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ : chr "a"
    ..$ : chr "b"
    ..$ : chr "c"
   $ y1:List of 3
    ..$ : chr "a"
    ..$ : chr "b"
    ..$ : chr "c"
  List of 2
   $ y0:List of 3
    ..$ : chr "a"
    ..$ : chr "b"
    ..$ : chr "c"
   $ y2:List of 3
    ..$ : chr "a"
    ..$ : chr "b"
    ..$ : chr "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2b3c5048> 
    ..$ ...          :<environment: 0x55ca2b3c5048> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.46 KiB (1496 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ : chr [1, 1] "a"
    ..$ : chr [1, 1] "b"
    ..$ : chr [1, 1] "c"
   $ y1:List of 3
    ..$ : chr [1, 1] "a"
    ..$ : chr [1, 1] "b"
    ..$ : chr [1, 1] "c"
  List of 2
   $ y0:List of 3
    ..$ : chr [1, 1] "a"
    ..$ : chr [1, 1] "b"
    ..$ : chr [1, 1] "c"
   $ y2:List of 3
    ..$ : chr [1, 1] "a"
    ..$ : chr [1, 1] "b"
    ..$ : chr [1, 1] "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2afb7680> 
    ..$ ...          :<environment: 0x55ca2afb7680> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.07 KiB (1096 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: chr [1:3] "a" "b" "c"
   $ y1: chr [1:3] "a" "b" "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2a86d450> 
    ..$ ...          :<environment: 0x55ca2a86d450> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.46 KiB (1496 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: chr [1:3] "a" "b" "c"
   $ y1: chr [1:3] "a" "b" "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2917e900> 
    ..$ ...          :<environment: 0x55ca2917e900> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.07 KiB (1096 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: chr [1:3] "a" "b" "c"
   $ y1: chr [1:3] "a" "b" "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2ae7d0c0> 
    ..$ ...          :<environment: 0x55ca2ae7d0c0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.46 KiB (1496 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: chr [1:3] "a" "b" "c"
   $ y1: chr [1:3] "a" "b" "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2a785ec0> 
    ..$ ...          :<environment: 0x55ca2a785ec0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.07 KiB (1096 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: chr "a"
    ..$ b: chr "b"
    ..$ c: chr "c"
   $ y1:List of 3
    ..$ a: chr "a"
    ..$ b: chr "b"
    ..$ c: chr "c"
  List of 2
   $ y0:List of 3
    ..$ a: chr "a"
    ..$ b: chr "b"
    ..$ c: chr "c"
   $ y2:List of 3
    ..$ : chr "a"
    ..$ : chr "b"
    ..$ : chr "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29686790> 
    ..$ ...          :<environment: 0x55ca29686790> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.46 KiB (1496 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: chr [1, 1] "a"
    ..$ b: chr [1, 1] "b"
    ..$ c: chr [1, 1] "c"
   $ y1:List of 3
    ..$ a: chr [1, 1] "a"
    ..$ b: chr [1, 1] "b"
    ..$ c: chr [1, 1] "c"
  List of 2
   $ y0:List of 3
    ..$ a: chr [1, 1] "a"
    ..$ b: chr [1, 1] "b"
    ..$ c: chr [1, 1] "c"
   $ y2:List of 3
    ..$ : chr [1, 1] "a"
    ..$ : chr [1, 1] "b"
    ..$ : chr [1, 1] "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29e25b98> 
    ..$ ...          :<environment: 0x55ca29e25b98> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.07 KiB (1096 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named chr [1:3] "a" "b" "c"
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named chr [1:3] "a" "b" "c"
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2b37fd50> 
    ..$ ...          :<environment: 0x55ca2b37fd50> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.46 KiB (1496 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named chr [1:3] "a" "b" "c"
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named chr [1:3] "a" "b" "c"
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2ab537d0> 
    ..$ ...          :<environment: 0x55ca2ab537d0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.07 KiB (1096 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named chr [1:3] "a" "b" "c"
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named chr [1:3] "a" "b" "c"
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2903b0b8> 
    ..$ ...          :<environment: 0x55ca2903b0b8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.46 KiB (1496 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named chr [1:3] "a" "b" "c"
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named chr [1:3] "a" "b" "c"
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29c4e430> 
    ..$ ...          :<environment: 0x55ca29c4e430> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.31 KiB (1344 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 4
    ..$ A: num 50
    ..$ B: num 60
    ..$ C: num 70
    ..$ D: num 80
   $ y1:List of 4
    ..$ A: num 50
    ..$ B: num 60
    ..$ C: num 70
    ..$ D: num 80
  List of 2
   $ y0:List of 4
    ..$ A: num 50
    ..$ B: num 60
    ..$ C: num 70
    ..$ D: num 80
   $ y2:List of 4
    ..$ A: num 50
    ..$ B: num 60
    ..$ C: num 70
    ..$ D: num 80
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2b325138> 
    ..$ ...          :<environment: 0x55ca2b325138> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.70 KiB (1744 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 4
    ..$ A: num [1, 1] 50
    ..$ B: num [1, 1] 60
    ..$ C: num [1, 1] 70
    ..$ D: num [1, 1] 80
   $ y1:List of 4
    ..$ A: num [1, 1] 50
    ..$ B: num [1, 1] 60
    ..$ C: num [1, 1] 70
    ..$ D: num [1, 1] 80
  List of 2
   $ y0:List of 4
    ..$ A: num [1, 1] 50
    ..$ B: num [1, 1] 60
    ..$ C: num [1, 1] 70
    ..$ D: num [1, 1] 80
   $ y2:List of 4
    ..$ A: num [1, 1] 50
    ..$ B: num [1, 1] 60
    ..$ C: num [1, 1] 70
    ..$ D: num [1, 1] 80
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2a731138> 
    ..$ ...          :<environment: 0x55ca2a731138> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.10 KiB (5224 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 4
    ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
    ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
    ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
    ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
   $ y1:List of 4
    ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
    ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
    ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
    ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
  List of 2
   $ y0:List of 4
    ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
    ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
    ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
    ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
   $ y2:List of 4
    ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
    ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
    ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
    ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2afe19c0> 
    ..$ ...          :<environment: 0x55ca2afe19c0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.31 KiB (1344 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
   $ y1: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2adde530> 
    ..$ ...          :<environment: 0x55ca2adde530> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.70 KiB (1744 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
   $ y1: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca28bc29a8> 
    ..$ ...          :<environment: 0x55ca28bc29a8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.10 KiB (5224 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: num [1:15, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:4] "A" "B" "C" "D"
   $ y1: num [1:15, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:4] "A" "B" "C" "D"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2b3c0830> 
    ..$ ...          :<environment: 0x55ca2b3c0830> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.31 KiB (1344 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
   $ y1: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2b36f688> 
    ..$ ...          :<environment: 0x55ca2b36f688> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.70 KiB (1744 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
   $ y1: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca290cd268> 
    ..$ ...          :<environment: 0x55ca290cd268> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.10 KiB (5224 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: num [1:3, 1:5, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:4] "A" "B" "C" "D"
   $ y1: num [1:3, 1:5, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:4] "A" "B" "C" "D"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29531d28> 
    ..$ ...          :<environment: 0x55ca29531d28> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.31 KiB (1344 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 4
    ..$ A: num 50
    ..$ B: num 60
    ..$ C: num 70
    ..$ D: num 80
   $ y1:List of 4
    ..$ A: num 50
    ..$ B: num 60
    ..$ C: num 70
    ..$ D: num 80
  List of 2
   $ y0:List of 4
    ..$ A: num 50
    ..$ B: num 60
    ..$ C: num 70
    ..$ D: num 80
   $ y2:List of 4
    ..$ A: num 50
    ..$ B: num 60
    ..$ C: num 70
    ..$ D: num 80
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2995c440> 
    ..$ ...          :<environment: 0x55ca2995c440> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.70 KiB (1744 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 4
    ..$ A: num [1, 1] 50
    ..$ B: num [1, 1] 60
    ..$ C: num [1, 1] 70
    ..$ D: num [1, 1] 80
   $ y1:List of 4
    ..$ A: num [1, 1] 50
    ..$ B: num [1, 1] 60
    ..$ C: num [1, 1] 70
    ..$ D: num [1, 1] 80
  List of 2
   $ y0:List of 4
    ..$ A: num [1, 1] 50
    ..$ B: num [1, 1] 60
    ..$ C: num [1, 1] 70
    ..$ D: num [1, 1] 80
   $ y2:List of 4
    ..$ A: num [1, 1] 50
    ..$ B: num [1, 1] 60
    ..$ C: num [1, 1] 70
    ..$ D: num [1, 1] 80
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29d6c460> 
    ..$ ...          :<environment: 0x55ca29d6c460> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.10 KiB (5224 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0:List of 4
    ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
    ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
    ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
    ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
   $ y1:List of 4
    ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
    ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
    ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
    ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
  List of 2
   $ y0:List of 4
    ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
    ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
    ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
    ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
   $ y2:List of 4
    ..$ A: num [1:3, 1:5] 100 100 100 200 200 200 300 300 300 400 ...
    ..$ B: num [1:3, 1:5] 120 120 120 240 240 240 360 360 360 480 ...
    ..$ C: num [1:3, 1:5] 140 140 140 280 280 280 420 420 420 560 ...
    ..$ D: num [1:3, 1:5] 160 160 160 320 320 320 480 480 480 640 ...
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29d87518> 
    ..$ ...          :<environment: 0x55ca29d87518> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.31 KiB (1344 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
   $ y1: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2b4d8650> 
    ..$ ...          :<environment: 0x55ca2b4d8650> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.70 KiB (1744 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
   $ y1: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2930fce0> 
    ..$ ...          :<environment: 0x55ca2930fce0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.10 KiB (5224 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: num [1:15, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:4] "A" "B" "C" "D"
   $ y1: num [1:15, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:4] "A" "B" "C" "D"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29169f28> 
    ..$ ...          :<environment: 0x55ca29169f28> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.31 KiB (1344 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
   $ y1: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2b584610> 
    ..$ ...          :<environment: 0x55ca2b584610> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.70 KiB (1744 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
   $ y1: Named num [1:4] 50 60 70 80
    ..- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2aca10a8> 
    ..$ ...          :<environment: 0x55ca2aca10a8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 5.10 KiB (5224 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  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_lapply() ... DONE
  List of 2
   $ y0: num [1:3, 1:5, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:4] "A" "B" "C" "D"
   $ y1: num [1:3, 1:5, 1:4] 100 100 100 200 200 200 300 300 300 400 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:4] "A" "B" "C" "D"
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(sequential)
  
  plan(): nbrOfWorkers() = 1
  *** strategy = 'sequential' ... done
  *** strategy = 'multicore' ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29b54840> 
    ..$ ...          :<environment: 0x55ca29b54840> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.10 KiB (1128 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.17 KiB (1200 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
   $ y1:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
  List of 2
   $ y0:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
   $ y2:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2b3781b0> 
    ..$ ...          :<environment: 0x55ca2b3781b0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.49 KiB (1528 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.56 KiB (1600 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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>
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  {
      {
          ...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
   $ y1:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
  List of 2
   $ y0:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
   $ y2:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2ab4e090> 
    ..$ ...          :<environment: 0x55ca2ab4e090> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 4.89 KiB (5008 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 4.96 KiB (5080 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  MulticoreFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  Resolving 2 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 2
  
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   length: 1 (resolved future 1)
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
   $ y1:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  List of 2
   $ y0:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
   $ y2:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca293dbd60> 
    ..$ ...          :<environment: 0x55ca293dbd60> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.10 KiB (1128 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  The total size of the 5 globals is 1.17 KiB (1200 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca297123e0> 
    ..$ ...          :<environment: 0x55ca297123e0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.49 KiB (1528 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.56 KiB (1600 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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>
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  {
      {
          ...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2979aaa8> 
    ..$ ...          :<environment: 0x55ca2979aaa8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 4.89 KiB (5008 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 4.96 KiB (5080 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
   length: 1 (resolved future 1)
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
   $ y1: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca291d2018> 
    ..$ ...          :<environment: 0x55ca291d2018> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.10 KiB (1128 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.17 KiB (1200 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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>
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  {
      {
          ...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca299532f8> 
    ..$ ...          :<environment: 0x55ca299532f8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.49 KiB (1528 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.56 KiB (1600 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29ba5a58> 
    ..$ ...          :<environment: 0x55ca29ba5a58> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 4.89 KiB (5008 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  
  
   - Finding globals in 'X' for chunk #2 ... DONE
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  getGlobalsAndPackages() ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  plan(): nbrOfWorkers() = 2
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 4.96 KiB (5080 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
   $ y1: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29d6c268> 
    ..$ ...          :<environment: 0x55ca29d6c268> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.10 KiB (1128 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  The total size of the 5 globals is 1.17 KiB (1200 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   length: 1 (resolved future 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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
   $ y1:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
  List of 2
   $ y0:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
   $ y2:List of 3
    ..$ a: num 1
    ..$ b: num 2
    ..$ c: num 3
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca291cbb10> 
    ..$ ...          :<environment: 0x55ca291cbb10> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.49 KiB (1528 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.56 KiB (1600 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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>
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  {
      {
          ...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
   $ y1:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
  List of 2
   $ y0:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
   $ y2:List of 3
    ..$ a: num [1, 1] 1
    ..$ b: num [1, 1] 2
    ..$ c: num [1, 1] 3
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2981aae0> 
    ..$ ...          :<environment: 0x55ca2981aae0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 4.89 KiB (5008 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 4.96 KiB (5080 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... DONE
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  {
      {
          ...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
   $ y1:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  List of 2
   $ y0:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
   $ y2:List of 3
    ..$ a: num [1:3, 1:5] 2 2 2 4 4 4 6 6 6 8 ...
    ..$ b: num [1:3, 1:5] 4 4 4 8 8 8 12 12 12 16 ...
    ..$ c: num [1:3, 1:5] 6 6 6 12 12 12 18 18 18 24 ...
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2a9c04a8> 
    ..$ ...          :<environment: 0x55ca2a9c04a8> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.10 KiB (1128 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.17 KiB (1200 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  MulticoreFuture started
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  Resolving 2 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 2
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  
  plan(): nbrOfWorkers() = 2
   length: 1 (resolved future 1)
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca2932ae00> 
    ..$ ...          :<environment: 0x55ca2932ae00> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.49 KiB (1528 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  The total size of the 5 globals is 1.56 KiB (1600 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... DONE
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca290d23c0> 
    ..$ ...          :<environment: 0x55ca290d23c0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 4.89 KiB (5008 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  The total size of the 5 globals is 4.96 KiB (5080 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
   $ y1: num [1:15, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 2
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29b34600> 
    ..$ ...          :<environment: 0x55ca29b34600> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.10 KiB (1128 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  The total size of the 5 globals is 1.17 KiB (1200 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   length: 1 (resolved future 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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29683f78> 
    ..$ ...          :<environment: 0x55ca29683f78> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.49 KiB (1528 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  - globals: [0] <none>
  plan(): nbrOfWorkers() = 1
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... DONE
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 2 * 5.24288e+08 = 1.04858e+09 (bytes)
   - seeds: <none>
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  getGlobalsAndPackages() ...
  plan(): nbrOfWorkers() = 2
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.56 KiB (1600 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
   $ y1: Named num [1:3] 1 2 3
    ..- attr(*, "names")= chr [1:3] "a" "b" "c"
  future_lapply() ...
  Finding globals ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] 'FUN', '*', ':', 'outer', 'rep'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 4.62 KiB (4728 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, y = 2 * 1:5)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca29c0a0e0> 
    ..$ ...          :<environment: 0x55ca29c0a0e0> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 4728
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... DONE
   - seeds: <none>
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 4.89 KiB (5008 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 4.96 KiB (5080 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  
  getGlobalsAndPackages() ... DONE
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...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(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
   $ y1: num [1:3, 1:5, 1:3] 2 2 2 4 4 4 6 6 6 8 ...
    ..- attr(*, "dimnames")=List of 3
    .. ..$ : NULL
    .. ..$ : NULL
    .. ..$ : chr [1:3] "a" "b" "c"
  future_lapply() ...
  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 848 bytes (848 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca28e40438> 
    ..$ ...          :<environment: 0x55ca28e40438> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 848
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.24 KiB (1272 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... DONE
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 3 * 5.24288e+08 = 1.57286e+09 (bytes)
   - seeds: <none>
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.24 KiB (1272 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  Chunk #2 of 2 ... DONE
  Launching 2 futures (chunks) ... DONE
  plan(): nbrOfWorkers() = 1
  Resolving 2 futures (chunks) ...
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
   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_lapply() ... DONE
  List of 2
   $ y0:List of 6
    ..$ a1: int 1
    ..$ a2: int 2
    ..$ b1: int 2
    ..$ b2: int 3
    ..$ c1: int 3
    ..$ c2: int 4
   $ y1:List of 6
    ..$ a1: int 1
    ..$ a2: int 2
    ..$ b1: int 2
    ..$ b2: int 3
    ..$ c1: int 3
    ..$ c2: int 4
  List of 2
   $ y0:List of 6
    ..$ a1: int 1
    ..$ a2: int 2
    ..$ b1: int 2
    ..$ b2: int 3
    ..$ c1: int 3
    ..$ c2: int 4
   $ y2:List of 6
    ..$ a1: int 1
    ..$ a2: int 2
    ..$ b1: int 2
    ..$ b2: int 3
    ..$ c1: int 3
    ..$ c2: int 4
  future_lapply() ...
  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.22 KiB (1248 bytes)
  - globals: [1] 'FUN'
  
  getGlobalsAndPackages() ... DONE
   - globals found: [1] 'FUN'
  
  Finding globals ... DONE
  Getting '...' globals ...
  resolve() on list ...
   recursive: 0
   length: 1
   elements: '...'
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  Getting '...' globals ... DONE
  Globals to be used in all futures:
  List of 2
   $ ...future.FUN:function (x, ...)  
   $ ...          : list()
    ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
   - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
   - attr(*, "where")=List of 2
    ..$ ...future.FUN:<environment: 0x55ca28bf8b58> 
    ..$ ...          :<environment: 0x55ca28bf8b58> 
   - attr(*, "resolved")= logi FALSE
   - attr(*, "total_size")= num 1248
  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 ...
   - Finding globals in 'X' for chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #1 ... 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', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.63 KiB (1672 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  Chunk #1 of 2 ... DONE
  Chunk #2 of 2 ...
   - Finding globals in 'X' for chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  
  
   - Finding globals in 'X' for chunk #2 ... DONE
   - Adjusted option 'future.globals.maxSize': 5.24288e+08 -> 3 * 5.24288e+08 = 1.57286e+09 (bytes)
   - seeds: <none>
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  getGlobalsAndPackages() ...
  - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
  Resolving globals: FALSE
  Tweak future expression to call with '...' arguments ...
  Tweak future expression to call with '...' arguments ... DONE
  The total size of the 5 globals is 1.63 KiB (1672 bytes)
  - globals: [5] '...future.FUN', 'future.call.arguments', '...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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...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)
                  }
                  lapply(seq_along(...future.elements_ii), FUN = function(jj) {
                    ...future.X_jj <- ...future.elements_ii[[jj]]
                    ...future.FUN(...future.X_jj, ...)
                  })
              })
              future::FutureResult(value = ...future.value, version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = s