R version 4.4.0 alpha (2024-03-26 r86209 ucrt)
Copyright (C) 2024 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> source("incl/start.R")
Loading required package: future
[15:32:43.825] plan(): Setting new future strategy stack:
[15:32:43.827] List of future strategies:
[15:32:43.827] 1. sequential:
[15:32:43.827]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:43.827]    - tweaked: FALSE
[15:32:43.827]    - call: future::plan("sequential")
[15:32:43.854] plan(): nbrOfWorkers() = 1
> 
> 
> message("*** future_vapply() ...")
*** future_vapply() ...
> 
> for (strategy in supportedStrategies()) {
+   message(sprintf("*** strategy = %s ...", sQuote(strategy)))
+   plan(strategy)
+   
+   x <- NULL
+   fun <- is.factor
+   fun_name <- "is.factor"
+   fun_value <- logical(1L)
+   y0 <- vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y0)
+   y1 <- future_vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+   y2 <- future_vapply(x, FUN = fun_name, FUN.VALUE = fun_value)
+   str(y2)
+   stopifnot(all.equal(y2, y0))
+   
+   x <- list()
+   fun <- is.numeric
+   fun_value <- logical(1L)
+   y0 <- vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y0)
+   y1 <- future_vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+   
+   x <- integer()
+   fun <- identity
+   fun_value <- fun(integer(1L))
+   y0 <- vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y0)
+   y1 <- future_vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+   
+   
+   df <- data.frame(x = 1:10, y = letters[1:10], stringsAsFactors=FALSE)
+   fun <- class
+   fun_value <- character(1L)
+   y0 <- vapply(df, FUN = fun, FUN.VALUE = fun_value)
+   str(y0)
+   y1 <- future_vapply(df, FUN = fun, FUN.VALUE = fun_value)
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+   
+   x <- 1:10
+   fun <- function(x) double(0L)
+   fun_value <- fun(double(1L))
+   y0 <- vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y0)
+   y1 <- future_vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+   
+   fun <- function(x) integer(0L)
+   fun_value <- fun(double(1L))
+   y0 <- vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y0)
+   y1 <- future_vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+   
+   fun <- sqrt
+   fun_value <- fun(double(1L))
+   y0 <- vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y0)
+   y1 <- future_vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+   
+   fun <- function(x) c(x, x^2)
+   fun_value <- fun(double(1L))
+   y0 <- vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y0)
+   y1 <- future_vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+   
+   fun <- function(x) matrix(x, nrow = 2L, ncol = 2L)
+   fun_value <- fun(integer(1L))
+   y0 <- vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y0)
+   y1 <- future_vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+   
+   fun <- function(x) matrix(x, nrow = 2L, ncol = 2L)
+   fun_value <- fun(double(1L))
+   y0 <- vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y0)
+   y1 <- future_vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+ 
+   ## Ditto with dimnames on FUN.VALUE
+   fun <- function(x) {
+     matrix(x, nrow = 2L, ncol = 2L, dimnames = list(c("a", "b"), c("A", "B")))
+   }
+   fun_value <- fun(double(1L))
+   y0 <- vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y0)
+   y1 <- future_vapply(x, FUN = fun, FUN.VALUE = fun_value)
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+   
+   message("- From example(vapply) ...")
+   x <- list(a = 1:10, beta = exp(-3:3), logic = c(TRUE, FALSE, FALSE, TRUE))
+   y0 <- vapply(x, FUN = quantile, FUN.VALUE = double(5L))
+   y1 <- future_vapply(x, FUN = quantile, FUN.VALUE = double(5L))
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+   
+   i39 <- sapply(3:9, seq)
+   ys0 <- sapply(i39, fivenum)
+   ys1 <- future_sapply(i39, fivenum)
+   stopifnot(all.equal(ys1, ys0))
+   
+   yv0 <- vapply(i39, fivenum,
+           c(Min. = 0, "1st Qu." = 0, Median = 0, "3rd Qu." = 0, Max. = 0))
+   yv1 <- future_vapply(i39, fivenum,
+          c(Min. = 0, "1st Qu." = 0, Median = 0, "3rd Qu." = 0, Max. = 0))
+   str(yv1)
+   stopifnot(all.equal(yv1, yv0))
+   
+   v <- structure(10*(5:8), names = LETTERS[1:4])
+   f <- function(x, y) outer(rep(x, length.out = 3L), y)
+   ys0 <- sapply(v, f, y = 2*(1:5), simplify = "array")
+   ys1 <- future_sapply(v, f, y = 2*(1:5), simplify = "array")
+   stopifnot(all.equal(ys1, ys0))
+   
+   fv <- outer(1:3, 1:5)
+   y <- 2*(1:5)
+   yv0 <- vapply(v, f, fv, y = y)
+   yv1 <- future_vapply(v, f, fv, y = y)
+   str(yv1)
+   stopifnot(all.equal(yv1, yv0))
+   
+   y0 <- vapply(mtcars, FUN = is.numeric, FUN.VALUE = logical(1L))
+   y1 <- future_vapply(mtcars, FUN = is.numeric, FUN.VALUE = logical(1L))
+   str(y1)
+   stopifnot(all.equal(y1, y0))
+ 
+   message("- future_vapply(x, ...) where length(x) != length(as.list(x)) ...")
+   x <- structure(list(a = 1, b = 2), class = "Foo")
+   as.list.Foo <- function(x, ...) c(x, c = 3)
+   y0 <- vapply(x, FUN = length, FUN.VALUE = -1L)
+   y1 <- future_vapply(x, FUN = length, FUN.VALUE = -1L)
+   stopifnot(identical(y1, y0))
+ 
+   message("- exceptions ...")
+   res <- tryCatch({
+     y0 <- vapply(1:3, FUN = identity, FUN.VALUE = c(3, 3))
+   }, error = identity)
+   stopifnot(inherits(res, "error"))
+   res <- tryCatch({
+     y1 <- future_vapply(1:3, FUN = identity, FUN.VALUE = c(3, 3))
+   }, error = identity)
+   stopifnot(inherits(res, "error"))
+   
+   plan(sequential)
+   message(sprintf("*** strategy = %s ... done", sQuote(strategy)))
+ } ## for (strategy in ...) 
*** strategy = 'sequential' ...
[15:32:44.092] plan(): Setting new future strategy stack:
[15:32:44.093] List of future strategies:
[15:32:44.093] 1. sequential:
[15:32:44.093]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.093]    - tweaked: FALSE
[15:32:44.093]    - call: plan(strategy)
[15:32:44.121] plan(): nbrOfWorkers() = 1
 logi(0) 
 logi(0) 
 logi(0) 
 logi(0) 
 logi(0) 
 int(0) 
 int(0) 
 Named chr [1:2] "integer" "character"
 - attr(*, "names")= chr [1:2] "x" "y"
[15:32:44.131] future_lapply() ...
[15:32:44.142] Number of chunks: 1
[15:32:44.143] getGlobalsAndPackagesXApply() ...
[15:32:44.143]  - future.globals: TRUE
[15:32:44.144] getGlobalsAndPackages() ...
[15:32:44.145] Searching for globals...
[15:32:44.154] - globals found: [16] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types'
[15:32:44.154] Searching for globals ... DONE
[15:32:44.154] Resolving globals: FALSE
[15:32:44.157] The total size of the 7 globals is 92.00 KiB (94208 bytes)
[15:32:44.159] The total size of the 7 globals exported for future expression ('FUN()') is 92.00 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:44.159] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.159] - packages: [1] 'future.apply'
[15:32:44.160] getGlobalsAndPackages() ... DONE
[15:32:44.160]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.160]  - needed namespaces: [n=1] 'future.apply'
[15:32:44.160] Finding globals ... DONE
[15:32:44.161]  - use_args: TRUE
[15:32:44.161]  - Getting '...' globals ...
[15:32:44.162] resolve() on list ...
[15:32:44.163]  recursive: 0
[15:32:44.163]  length: 1
[15:32:44.164]  elements: '...'
[15:32:44.164]  length: 0 (resolved future 1)
[15:32:44.164] resolve() on list ... DONE
[15:32:44.164]    - '...' content: [n=0] 
[15:32:44.165] List of 1
[15:32:44.165]  $ ...: list()
[15:32:44.165]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.165]  - attr(*, "where")=List of 1
[15:32:44.165]   ..$ ...:<environment: 0x0000022d3d815d10> 
[15:32:44.165]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.165]  - attr(*, "resolved")= logi TRUE
[15:32:44.165]  - attr(*, "total_size")= num NA
[15:32:44.178]  - Getting '...' globals ... DONE
[15:32:44.179] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:44.179] List of 8
[15:32:44.179]  $ ...future.FUN:function (x, ...)  
[15:32:44.179]  $ x_FUN        :function (x)  
[15:32:44.179]  $ times        : int 1
[15:32:44.179]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.179]  $ stop_if_not  :function (...)  
[15:32:44.179]  $ dim          : NULL
[15:32:44.179]  $ valid_types  : chr "character"
[15:32:44.179]  $ ...          : list()
[15:32:44.179]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.179]  - attr(*, "where")=List of 8
[15:32:44.179]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:44.179]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:44.179]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:44.179]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:44.179]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:44.179]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:44.179]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:44.179]   ..$ ...          :<environment: 0x0000022d3d815d10> 
[15:32:44.179]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.179]  - attr(*, "resolved")= logi FALSE
[15:32:44.179]  - attr(*, "total_size")= num 94208
[15:32:44.189] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:44.189] getGlobalsAndPackagesXApply() ... DONE
[15:32:44.190] Number of futures (= number of chunks): 1
[15:32:44.190] Launching 1 futures (chunks) ...
[15:32:44.190] Chunk #1 of 1 ...
[15:32:44.191]  - Finding globals in 'X' for chunk #1 ...
[15:32:44.191] getGlobalsAndPackages() ...
[15:32:44.191] Searching for globals...
[15:32:44.192] 
[15:32:44.192] Searching for globals ... DONE
[15:32:44.193] - globals: [0] <none>
[15:32:44.193] getGlobalsAndPackages() ... DONE
[15:32:44.193]    + additional globals found: [n=0] 
[15:32:44.193]    + additional namespaces needed: [n=0] 
[15:32:44.194]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:44.194]  - seeds: <none>
[15:32:44.194]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.195] getGlobalsAndPackages() ...
[15:32:44.195] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.195] Resolving globals: FALSE
[15:32:44.195] Tweak future expression to call with '...' arguments ...
[15:32:44.196] {
[15:32:44.196]     do.call(function(...) {
[15:32:44.196]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.196]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:44.196]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.196]             on.exit(options(oopts), add = TRUE)
[15:32:44.196]         }
[15:32:44.196]         {
[15:32:44.196]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:44.196]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.196]                 ...future.FUN(...future.X_jj, ...)
[15:32:44.196]             })
[15:32:44.196]         }
[15:32:44.196]     }, args = future.call.arguments)
[15:32:44.196] }
[15:32:44.196] Tweak future expression to call with '...' arguments ... DONE
[15:32:44.197] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.198] - packages: [1] 'future.apply'
[15:32:44.198] getGlobalsAndPackages() ... DONE
[15:32:44.200] run() for 'Future' ...
[15:32:44.200] - state: 'created'
[15:32:44.201] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:44.201] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:44.202] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:44.202]   - Field: 'label'
[15:32:44.202]   - Field: 'local'
[15:32:44.203]   - Field: 'owner'
[15:32:44.203]   - Field: 'envir'
[15:32:44.204]   - Field: 'packages'
[15:32:44.204]   - Field: 'gc'
[15:32:44.204]   - Field: 'conditions'
[15:32:44.204]   - Field: 'expr'
[15:32:44.205]   - Field: 'uuid'
[15:32:44.205]   - Field: 'seed'
[15:32:44.205]   - Field: 'version'
[15:32:44.206]   - Field: 'result'
[15:32:44.206]   - Field: 'asynchronous'
[15:32:44.206]   - Field: 'calls'
[15:32:44.207]   - Field: 'globals'
[15:32:44.207]   - Field: 'stdout'
[15:32:44.207]   - Field: 'earlySignal'
[15:32:44.208]   - Field: 'lazy'
[15:32:44.208]   - Field: 'state'
[15:32:44.208] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:44.209] - Launch lazy future ...
[15:32:44.210] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:44.210] Packages needed by future strategies (n = 0): <none>
[15:32:44.212] {
[15:32:44.212]     {
[15:32:44.212]         {
[15:32:44.212]             ...future.startTime <- base::Sys.time()
[15:32:44.212]             {
[15:32:44.212]                 {
[15:32:44.212]                   {
[15:32:44.212]                     {
[15:32:44.212]                       base::local({
[15:32:44.212]                         has_future <- base::requireNamespace("future", 
[15:32:44.212]                           quietly = TRUE)
[15:32:44.212]                         if (has_future) {
[15:32:44.212]                           ns <- base::getNamespace("future")
[15:32:44.212]                           version <- ns[[".package"]][["version"]]
[15:32:44.212]                           if (is.null(version)) 
[15:32:44.212]                             version <- utils::packageVersion("future")
[15:32:44.212]                         }
[15:32:44.212]                         else {
[15:32:44.212]                           version <- NULL
[15:32:44.212]                         }
[15:32:44.212]                         if (!has_future || version < "1.8.0") {
[15:32:44.212]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:44.212]                             "", base::R.version$version.string), 
[15:32:44.212]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:44.212]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:44.212]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:44.212]                               "release", "version")], collapse = " "), 
[15:32:44.212]                             hostname = base::Sys.info()[["nodename"]])
[15:32:44.212]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:44.212]                             info)
[15:32:44.212]                           info <- base::paste(info, collapse = "; ")
[15:32:44.212]                           if (!has_future) {
[15:32:44.212]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:44.212]                               info)
[15:32:44.212]                           }
[15:32:44.212]                           else {
[15:32:44.212]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:44.212]                               info, version)
[15:32:44.212]                           }
[15:32:44.212]                           base::stop(msg)
[15:32:44.212]                         }
[15:32:44.212]                       })
[15:32:44.212]                     }
[15:32:44.212]                     base::local({
[15:32:44.212]                       for (pkg in "future.apply") {
[15:32:44.212]                         base::loadNamespace(pkg)
[15:32:44.212]                         base::library(pkg, character.only = TRUE)
[15:32:44.212]                       }
[15:32:44.212]                     })
[15:32:44.212]                   }
[15:32:44.212]                   ...future.strategy.old <- future::plan("list")
[15:32:44.212]                   options(future.plan = NULL)
[15:32:44.212]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:44.212]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:44.212]                 }
[15:32:44.212]                 ...future.workdir <- getwd()
[15:32:44.212]             }
[15:32:44.212]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:44.212]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:44.212]         }
[15:32:44.212]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:44.212]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:44.212]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:44.212]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:44.212]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:44.212]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:44.212]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:44.212]             base::names(...future.oldOptions))
[15:32:44.212]     }
[15:32:44.212]     if (FALSE) {
[15:32:44.212]     }
[15:32:44.212]     else {
[15:32:44.212]         if (TRUE) {
[15:32:44.212]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:44.212]                 open = "w")
[15:32:44.212]         }
[15:32:44.212]         else {
[15:32:44.212]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:44.212]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:44.212]         }
[15:32:44.212]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:44.212]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:44.212]             base::sink(type = "output", split = FALSE)
[15:32:44.212]             base::close(...future.stdout)
[15:32:44.212]         }, add = TRUE)
[15:32:44.212]     }
[15:32:44.212]     ...future.frame <- base::sys.nframe()
[15:32:44.212]     ...future.conditions <- base::list()
[15:32:44.212]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:44.212]     if (FALSE) {
[15:32:44.212]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:44.212]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:44.212]     }
[15:32:44.212]     ...future.result <- base::tryCatch({
[15:32:44.212]         base::withCallingHandlers({
[15:32:44.212]             ...future.value <- base::withVisible(base::local({
[15:32:44.212]                 do.call(function(...) {
[15:32:44.212]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.212]                   if (!identical(...future.globals.maxSize.org, 
[15:32:44.212]                     ...future.globals.maxSize)) {
[15:32:44.212]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.212]                     on.exit(options(oopts), add = TRUE)
[15:32:44.212]                   }
[15:32:44.212]                   {
[15:32:44.212]                     lapply(seq_along(...future.elements_ii), 
[15:32:44.212]                       FUN = function(jj) {
[15:32:44.212]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.212]                         ...future.FUN(...future.X_jj, ...)
[15:32:44.212]                       })
[15:32:44.212]                   }
[15:32:44.212]                 }, args = future.call.arguments)
[15:32:44.212]             }))
[15:32:44.212]             future::FutureResult(value = ...future.value$value, 
[15:32:44.212]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:44.212]                   ...future.rng), globalenv = if (FALSE) 
[15:32:44.212]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:44.212]                     ...future.globalenv.names))
[15:32:44.212]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:44.212]         }, condition = base::local({
[15:32:44.212]             c <- base::c
[15:32:44.212]             inherits <- base::inherits
[15:32:44.212]             invokeRestart <- base::invokeRestart
[15:32:44.212]             length <- base::length
[15:32:44.212]             list <- base::list
[15:32:44.212]             seq.int <- base::seq.int
[15:32:44.212]             signalCondition <- base::signalCondition
[15:32:44.212]             sys.calls <- base::sys.calls
[15:32:44.212]             `[[` <- base::`[[`
[15:32:44.212]             `+` <- base::`+`
[15:32:44.212]             `<<-` <- base::`<<-`
[15:32:44.212]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:44.212]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:44.212]                   3L)]
[15:32:44.212]             }
[15:32:44.212]             function(cond) {
[15:32:44.212]                 is_error <- inherits(cond, "error")
[15:32:44.212]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:44.212]                   NULL)
[15:32:44.212]                 if (is_error) {
[15:32:44.212]                   sessionInformation <- function() {
[15:32:44.212]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:44.212]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:44.212]                       search = base::search(), system = base::Sys.info())
[15:32:44.212]                   }
[15:32:44.212]                   ...future.conditions[[length(...future.conditions) + 
[15:32:44.212]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:44.212]                     cond$call), session = sessionInformation(), 
[15:32:44.212]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:44.212]                   signalCondition(cond)
[15:32:44.212]                 }
[15:32:44.212]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:44.212]                 "immediateCondition"))) {
[15:32:44.212]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:44.212]                   ...future.conditions[[length(...future.conditions) + 
[15:32:44.212]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:44.212]                   if (TRUE && !signal) {
[15:32:44.212]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:44.212]                     {
[15:32:44.212]                       inherits <- base::inherits
[15:32:44.212]                       invokeRestart <- base::invokeRestart
[15:32:44.212]                       is.null <- base::is.null
[15:32:44.212]                       muffled <- FALSE
[15:32:44.212]                       if (inherits(cond, "message")) {
[15:32:44.212]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:44.212]                         if (muffled) 
[15:32:44.212]                           invokeRestart("muffleMessage")
[15:32:44.212]                       }
[15:32:44.212]                       else if (inherits(cond, "warning")) {
[15:32:44.212]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:44.212]                         if (muffled) 
[15:32:44.212]                           invokeRestart("muffleWarning")
[15:32:44.212]                       }
[15:32:44.212]                       else if (inherits(cond, "condition")) {
[15:32:44.212]                         if (!is.null(pattern)) {
[15:32:44.212]                           computeRestarts <- base::computeRestarts
[15:32:44.212]                           grepl <- base::grepl
[15:32:44.212]                           restarts <- computeRestarts(cond)
[15:32:44.212]                           for (restart in restarts) {
[15:32:44.212]                             name <- restart$name
[15:32:44.212]                             if (is.null(name)) 
[15:32:44.212]                               next
[15:32:44.212]                             if (!grepl(pattern, name)) 
[15:32:44.212]                               next
[15:32:44.212]                             invokeRestart(restart)
[15:32:44.212]                             muffled <- TRUE
[15:32:44.212]                             break
[15:32:44.212]                           }
[15:32:44.212]                         }
[15:32:44.212]                       }
[15:32:44.212]                       invisible(muffled)
[15:32:44.212]                     }
[15:32:44.212]                     muffleCondition(cond, pattern = "^muffle")
[15:32:44.212]                   }
[15:32:44.212]                 }
[15:32:44.212]                 else {
[15:32:44.212]                   if (TRUE) {
[15:32:44.212]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:44.212]                     {
[15:32:44.212]                       inherits <- base::inherits
[15:32:44.212]                       invokeRestart <- base::invokeRestart
[15:32:44.212]                       is.null <- base::is.null
[15:32:44.212]                       muffled <- FALSE
[15:32:44.212]                       if (inherits(cond, "message")) {
[15:32:44.212]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:44.212]                         if (muffled) 
[15:32:44.212]                           invokeRestart("muffleMessage")
[15:32:44.212]                       }
[15:32:44.212]                       else if (inherits(cond, "warning")) {
[15:32:44.212]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:44.212]                         if (muffled) 
[15:32:44.212]                           invokeRestart("muffleWarning")
[15:32:44.212]                       }
[15:32:44.212]                       else if (inherits(cond, "condition")) {
[15:32:44.212]                         if (!is.null(pattern)) {
[15:32:44.212]                           computeRestarts <- base::computeRestarts
[15:32:44.212]                           grepl <- base::grepl
[15:32:44.212]                           restarts <- computeRestarts(cond)
[15:32:44.212]                           for (restart in restarts) {
[15:32:44.212]                             name <- restart$name
[15:32:44.212]                             if (is.null(name)) 
[15:32:44.212]                               next
[15:32:44.212]                             if (!grepl(pattern, name)) 
[15:32:44.212]                               next
[15:32:44.212]                             invokeRestart(restart)
[15:32:44.212]                             muffled <- TRUE
[15:32:44.212]                             break
[15:32:44.212]                           }
[15:32:44.212]                         }
[15:32:44.212]                       }
[15:32:44.212]                       invisible(muffled)
[15:32:44.212]                     }
[15:32:44.212]                     muffleCondition(cond, pattern = "^muffle")
[15:32:44.212]                   }
[15:32:44.212]                 }
[15:32:44.212]             }
[15:32:44.212]         }))
[15:32:44.212]     }, error = function(ex) {
[15:32:44.212]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:44.212]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:44.212]                 ...future.rng), started = ...future.startTime, 
[15:32:44.212]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:44.212]             version = "1.8"), class = "FutureResult")
[15:32:44.212]     }, finally = {
[15:32:44.212]         if (!identical(...future.workdir, getwd())) 
[15:32:44.212]             setwd(...future.workdir)
[15:32:44.212]         {
[15:32:44.212]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:44.212]                 ...future.oldOptions$nwarnings <- NULL
[15:32:44.212]             }
[15:32:44.212]             base::options(...future.oldOptions)
[15:32:44.212]             if (.Platform$OS.type == "windows") {
[15:32:44.212]                 old_names <- names(...future.oldEnvVars)
[15:32:44.212]                 envs <- base::Sys.getenv()
[15:32:44.212]                 names <- names(envs)
[15:32:44.212]                 common <- intersect(names, old_names)
[15:32:44.212]                 added <- setdiff(names, old_names)
[15:32:44.212]                 removed <- setdiff(old_names, names)
[15:32:44.212]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:44.212]                   envs[common]]
[15:32:44.212]                 NAMES <- toupper(changed)
[15:32:44.212]                 args <- list()
[15:32:44.212]                 for (kk in seq_along(NAMES)) {
[15:32:44.212]                   name <- changed[[kk]]
[15:32:44.212]                   NAME <- NAMES[[kk]]
[15:32:44.212]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.212]                     next
[15:32:44.212]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:44.212]                 }
[15:32:44.212]                 NAMES <- toupper(added)
[15:32:44.212]                 for (kk in seq_along(NAMES)) {
[15:32:44.212]                   name <- added[[kk]]
[15:32:44.212]                   NAME <- NAMES[[kk]]
[15:32:44.212]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.212]                     next
[15:32:44.212]                   args[[name]] <- ""
[15:32:44.212]                 }
[15:32:44.212]                 NAMES <- toupper(removed)
[15:32:44.212]                 for (kk in seq_along(NAMES)) {
[15:32:44.212]                   name <- removed[[kk]]
[15:32:44.212]                   NAME <- NAMES[[kk]]
[15:32:44.212]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.212]                     next
[15:32:44.212]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:44.212]                 }
[15:32:44.212]                 if (length(args) > 0) 
[15:32:44.212]                   base::do.call(base::Sys.setenv, args = args)
[15:32:44.212]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:44.212]             }
[15:32:44.212]             else {
[15:32:44.212]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:44.212]             }
[15:32:44.212]             {
[15:32:44.212]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:44.212]                   0L) {
[15:32:44.212]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:44.212]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:44.212]                   base::options(opts)
[15:32:44.212]                 }
[15:32:44.212]                 {
[15:32:44.212]                   {
[15:32:44.212]                     NULL
[15:32:44.212]                     RNGkind("Mersenne-Twister")
[15:32:44.212]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:44.212]                       inherits = FALSE)
[15:32:44.212]                   }
[15:32:44.212]                   options(future.plan = NULL)
[15:32:44.212]                   if (is.na(NA_character_)) 
[15:32:44.212]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:44.212]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:44.212]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:44.212]                     .init = FALSE)
[15:32:44.212]                 }
[15:32:44.212]             }
[15:32:44.212]         }
[15:32:44.212]     })
[15:32:44.212]     if (TRUE) {
[15:32:44.212]         base::sink(type = "output", split = FALSE)
[15:32:44.212]         if (TRUE) {
[15:32:44.212]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:44.212]         }
[15:32:44.212]         else {
[15:32:44.212]             ...future.result["stdout"] <- base::list(NULL)
[15:32:44.212]         }
[15:32:44.212]         base::close(...future.stdout)
[15:32:44.212]         ...future.stdout <- NULL
[15:32:44.212]     }
[15:32:44.212]     ...future.result$conditions <- ...future.conditions
[15:32:44.212]     ...future.result$finished <- base::Sys.time()
[15:32:44.212]     ...future.result
[15:32:44.212] }
[15:32:44.220] assign_globals() ...
[15:32:44.221] List of 11
[15:32:44.221]  $ ...future.FUN            :function (x, ...)  
[15:32:44.221]  $ x_FUN                    :function (x)  
[15:32:44.221]  $ times                    : int 1
[15:32:44.221]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.221]  $ stop_if_not              :function (...)  
[15:32:44.221]  $ dim                      : NULL
[15:32:44.221]  $ valid_types              : chr "character"
[15:32:44.221]  $ future.call.arguments    : list()
[15:32:44.221]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.221]  $ ...future.elements_ii    :List of 2
[15:32:44.221]   ..$ x: int [1:10] 1 2 3 4 5 6 7 8 9 10
[15:32:44.221]   ..$ y: chr [1:10] "a" "b" "c" "d" ...
[15:32:44.221]  $ ...future.seeds_ii       : NULL
[15:32:44.221]  $ ...future.globals.maxSize: NULL
[15:32:44.221]  - attr(*, "where")=List of 11
[15:32:44.221]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:44.221]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:44.221]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:44.221]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:44.221]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:44.221]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:44.221]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:44.221]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:44.221]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:44.221]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:44.221]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:44.221]  - attr(*, "resolved")= logi FALSE
[15:32:44.221]  - attr(*, "total_size")= num 94208
[15:32:44.221]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.221]  - attr(*, "already-done")= logi TRUE
[15:32:44.243] - copied '...future.FUN' to environment
[15:32:44.244] - copied 'x_FUN' to environment
[15:32:44.244] - copied 'times' to environment
[15:32:44.244] - copied 'stopf' to environment
[15:32:44.245] - copied 'stop_if_not' to environment
[15:32:44.245] - copied 'dim' to environment
[15:32:44.245] - copied 'valid_types' to environment
[15:32:44.245] - copied 'future.call.arguments' to environment
[15:32:44.246] - copied '...future.elements_ii' to environment
[15:32:44.246] - copied '...future.seeds_ii' to environment
[15:32:44.246] - copied '...future.globals.maxSize' to environment
[15:32:44.247] assign_globals() ... done
[15:32:44.248] plan(): Setting new future strategy stack:
[15:32:44.248] List of future strategies:
[15:32:44.248] 1. sequential:
[15:32:44.248]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.248]    - tweaked: FALSE
[15:32:44.248]    - call: NULL
[15:32:44.249] plan(): nbrOfWorkers() = 1
[15:32:44.252] plan(): Setting new future strategy stack:
[15:32:44.253] List of future strategies:
[15:32:44.253] 1. sequential:
[15:32:44.253]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.253]    - tweaked: FALSE
[15:32:44.253]    - call: plan(strategy)
[15:32:44.254] plan(): nbrOfWorkers() = 1
[15:32:44.254] SequentialFuture started (and completed)
[15:32:44.255] - Launch lazy future ... done
[15:32:44.255] run() for 'SequentialFuture' ... done
[15:32:44.255] Created future:
[15:32:44.256] SequentialFuture:
[15:32:44.256] Label: 'future_vapply-1'
[15:32:44.256] Expression:
[15:32:44.256] {
[15:32:44.256]     do.call(function(...) {
[15:32:44.256]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.256]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:44.256]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.256]             on.exit(options(oopts), add = TRUE)
[15:32:44.256]         }
[15:32:44.256]         {
[15:32:44.256]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:44.256]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.256]                 ...future.FUN(...future.X_jj, ...)
[15:32:44.256]             })
[15:32:44.256]         }
[15:32:44.256]     }, args = future.call.arguments)
[15:32:44.256] }
[15:32:44.256] Lazy evaluation: FALSE
[15:32:44.256] Asynchronous evaluation: FALSE
[15:32:44.256] Local evaluation: TRUE
[15:32:44.256] Environment: R_GlobalEnv
[15:32:44.256] Capture standard output: TRUE
[15:32:44.256] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:44.256] Globals: 11 objects totaling 92.81 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 56 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:44.256] Packages: 1 packages ('future.apply')
[15:32:44.256] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:44.256] Resolved: TRUE
[15:32:44.256] Value: 232 bytes of class 'list'
[15:32:44.256] Early signaling: FALSE
[15:32:44.256] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:44.256] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:44.258] Chunk #1 of 1 ... DONE
[15:32:44.259] Launching 1 futures (chunks) ... DONE
[15:32:44.259] Resolving 1 futures (chunks) ...
[15:32:44.259] resolve() on list ...
[15:32:44.259]  recursive: 0
[15:32:44.260]  length: 1
[15:32:44.260] 
[15:32:44.260] resolved() for 'SequentialFuture' ...
[15:32:44.261] - state: 'finished'
[15:32:44.261] - run: TRUE
[15:32:44.261] - result: 'FutureResult'
[15:32:44.261] resolved() for 'SequentialFuture' ... done
[15:32:44.262] Future #1
[15:32:44.262] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:44.262] - nx: 1
[15:32:44.263] - relay: TRUE
[15:32:44.263] - stdout: TRUE
[15:32:44.263] - signal: TRUE
[15:32:44.263] - resignal: FALSE
[15:32:44.263] - force: TRUE
[15:32:44.264] - relayed: [n=1] FALSE
[15:32:44.264] - queued futures: [n=1] FALSE
[15:32:44.264]  - until=1
[15:32:44.264]  - relaying element #1
[15:32:44.265] - relayed: [n=1] TRUE
[15:32:44.265] - queued futures: [n=1] TRUE
[15:32:44.265] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:44.266]  length: 0 (resolved future 1)
[15:32:44.266] Relaying remaining futures
[15:32:44.266] signalConditionsASAP(NULL, pos=0) ...
[15:32:44.267] - nx: 1
[15:32:44.267] - relay: TRUE
[15:32:44.267] - stdout: TRUE
[15:32:44.268] - signal: TRUE
[15:32:44.268] - resignal: FALSE
[15:32:44.268] - force: TRUE
[15:32:44.268] - relayed: [n=1] TRUE
[15:32:44.269] - queued futures: [n=1] TRUE
 - flush all
[15:32:44.269] - relayed: [n=1] TRUE
[15:32:44.270] - queued futures: [n=1] TRUE
[15:32:44.270] signalConditionsASAP(NULL, pos=0) ... done
[15:32:44.270] resolve() on list ... DONE
[15:32:44.271]  - Number of value chunks collected: 1
[15:32:44.271] Resolving 1 futures (chunks) ... DONE
[15:32:44.271] Reducing values from 1 chunks ...
[15:32:44.271]  - Number of values collected after concatenation: 2
[15:32:44.272]  - Number of values expected: 2
[15:32:44.272] Reducing values from 1 chunks ... DONE
[15:32:44.273] future_lapply() ... DONE
 Named chr [1:2] "integer" "character"
 - attr(*, "names")= chr [1:2] "x" "y"
 num[0 , 1:10] 
[15:32:44.276] future_lapply() ...
[15:32:44.283] Number of chunks: 1
[15:32:44.284] getGlobalsAndPackagesXApply() ...
[15:32:44.284]  - future.globals: TRUE
[15:32:44.284] getGlobalsAndPackages() ...
[15:32:44.284] Searching for globals...
[15:32:44.290] - globals found: [17] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'double'
[15:32:44.291] Searching for globals ... DONE
[15:32:44.291] Resolving globals: FALSE
[15:32:44.293] The total size of the 7 globals is 93.23 KiB (95472 bytes)
[15:32:44.293] The total size of the 7 globals exported for future expression ('FUN()') is 93.23 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:44.294] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.294] - packages: [1] 'future.apply'
[15:32:44.294] getGlobalsAndPackages() ... DONE
[15:32:44.294]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.295]  - needed namespaces: [n=1] 'future.apply'
[15:32:44.295] Finding globals ... DONE
[15:32:44.295]  - use_args: TRUE
[15:32:44.295]  - Getting '...' globals ...
[15:32:44.296] resolve() on list ...
[15:32:44.296]  recursive: 0
[15:32:44.296]  length: 1
[15:32:44.296]  elements: '...'
[15:32:44.297]  length: 0 (resolved future 1)
[15:32:44.297] resolve() on list ... DONE
[15:32:44.297]    - '...' content: [n=0] 
[15:32:44.297] List of 1
[15:32:44.297]  $ ...: list()
[15:32:44.297]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.297]  - attr(*, "where")=List of 1
[15:32:44.297]   ..$ ...:<environment: 0x0000022d3e6ac998> 
[15:32:44.297]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.297]  - attr(*, "resolved")= logi TRUE
[15:32:44.297]  - attr(*, "total_size")= num NA
[15:32:44.302]  - Getting '...' globals ... DONE
[15:32:44.302] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:44.302] List of 8
[15:32:44.302]  $ ...future.FUN:function (x, ...)  
[15:32:44.302]  $ x_FUN        :function (x)  
[15:32:44.302]  $ times        : int 0
[15:32:44.302]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.302]  $ stop_if_not  :function (...)  
[15:32:44.302]  $ dim          : NULL
[15:32:44.302]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:44.302]  $ ...          : list()
[15:32:44.302]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.302]  - attr(*, "where")=List of 8
[15:32:44.302]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:44.302]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:44.302]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:44.302]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:44.302]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:44.302]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:44.302]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:44.302]   ..$ ...          :<environment: 0x0000022d3e6ac998> 
[15:32:44.302]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.302]  - attr(*, "resolved")= logi FALSE
[15:32:44.302]  - attr(*, "total_size")= num 95472
[15:32:44.318] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:44.319] getGlobalsAndPackagesXApply() ... DONE
[15:32:44.319] Number of futures (= number of chunks): 1
[15:32:44.320] Launching 1 futures (chunks) ...
[15:32:44.320] Chunk #1 of 1 ...
[15:32:44.320]  - Finding globals in 'X' for chunk #1 ...
[15:32:44.321] getGlobalsAndPackages() ...
[15:32:44.321] Searching for globals...
[15:32:44.322] 
[15:32:44.322] Searching for globals ... DONE
[15:32:44.323] - globals: [0] <none>
[15:32:44.323] getGlobalsAndPackages() ... DONE
[15:32:44.323]    + additional globals found: [n=0] 
[15:32:44.324]    + additional namespaces needed: [n=0] 
[15:32:44.324]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:44.324]  - seeds: <none>
[15:32:44.325]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.325] getGlobalsAndPackages() ...
[15:32:44.325] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.326] Resolving globals: FALSE
[15:32:44.326] Tweak future expression to call with '...' arguments ...
[15:32:44.326] {
[15:32:44.326]     do.call(function(...) {
[15:32:44.326]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.326]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:44.326]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.326]             on.exit(options(oopts), add = TRUE)
[15:32:44.326]         }
[15:32:44.326]         {
[15:32:44.326]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:44.326]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.326]                 ...future.FUN(...future.X_jj, ...)
[15:32:44.326]             })
[15:32:44.326]         }
[15:32:44.326]     }, args = future.call.arguments)
[15:32:44.326] }
[15:32:44.327] Tweak future expression to call with '...' arguments ... DONE
[15:32:44.328] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.328] - packages: [1] 'future.apply'
[15:32:44.329] getGlobalsAndPackages() ... DONE
[15:32:44.329] run() for 'Future' ...
[15:32:44.330] - state: 'created'
[15:32:44.330] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:44.331] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:44.331] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:44.331]   - Field: 'label'
[15:32:44.332]   - Field: 'local'
[15:32:44.332]   - Field: 'owner'
[15:32:44.332]   - Field: 'envir'
[15:32:44.332]   - Field: 'packages'
[15:32:44.333]   - Field: 'gc'
[15:32:44.333]   - Field: 'conditions'
[15:32:44.333]   - Field: 'expr'
[15:32:44.333]   - Field: 'uuid'
[15:32:44.334]   - Field: 'seed'
[15:32:44.334]   - Field: 'version'
[15:32:44.334]   - Field: 'result'
[15:32:44.335]   - Field: 'asynchronous'
[15:32:44.335]   - Field: 'calls'
[15:32:44.336]   - Field: 'globals'
[15:32:44.336]   - Field: 'stdout'
[15:32:44.336]   - Field: 'earlySignal'
[15:32:44.337]   - Field: 'lazy'
[15:32:44.337]   - Field: 'state'
[15:32:44.338] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:44.338] - Launch lazy future ...
[15:32:44.339] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:44.339] Packages needed by future strategies (n = 0): <none>
[15:32:44.340] {
[15:32:44.340]     {
[15:32:44.340]         {
[15:32:44.340]             ...future.startTime <- base::Sys.time()
[15:32:44.340]             {
[15:32:44.340]                 {
[15:32:44.340]                   {
[15:32:44.340]                     {
[15:32:44.340]                       base::local({
[15:32:44.340]                         has_future <- base::requireNamespace("future", 
[15:32:44.340]                           quietly = TRUE)
[15:32:44.340]                         if (has_future) {
[15:32:44.340]                           ns <- base::getNamespace("future")
[15:32:44.340]                           version <- ns[[".package"]][["version"]]
[15:32:44.340]                           if (is.null(version)) 
[15:32:44.340]                             version <- utils::packageVersion("future")
[15:32:44.340]                         }
[15:32:44.340]                         else {
[15:32:44.340]                           version <- NULL
[15:32:44.340]                         }
[15:32:44.340]                         if (!has_future || version < "1.8.0") {
[15:32:44.340]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:44.340]                             "", base::R.version$version.string), 
[15:32:44.340]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:44.340]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:44.340]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:44.340]                               "release", "version")], collapse = " "), 
[15:32:44.340]                             hostname = base::Sys.info()[["nodename"]])
[15:32:44.340]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:44.340]                             info)
[15:32:44.340]                           info <- base::paste(info, collapse = "; ")
[15:32:44.340]                           if (!has_future) {
[15:32:44.340]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:44.340]                               info)
[15:32:44.340]                           }
[15:32:44.340]                           else {
[15:32:44.340]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:44.340]                               info, version)
[15:32:44.340]                           }
[15:32:44.340]                           base::stop(msg)
[15:32:44.340]                         }
[15:32:44.340]                       })
[15:32:44.340]                     }
[15:32:44.340]                     base::local({
[15:32:44.340]                       for (pkg in "future.apply") {
[15:32:44.340]                         base::loadNamespace(pkg)
[15:32:44.340]                         base::library(pkg, character.only = TRUE)
[15:32:44.340]                       }
[15:32:44.340]                     })
[15:32:44.340]                   }
[15:32:44.340]                   ...future.strategy.old <- future::plan("list")
[15:32:44.340]                   options(future.plan = NULL)
[15:32:44.340]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:44.340]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:44.340]                 }
[15:32:44.340]                 ...future.workdir <- getwd()
[15:32:44.340]             }
[15:32:44.340]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:44.340]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:44.340]         }
[15:32:44.340]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:44.340]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:44.340]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:44.340]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:44.340]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:44.340]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:44.340]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:44.340]             base::names(...future.oldOptions))
[15:32:44.340]     }
[15:32:44.340]     if (FALSE) {
[15:32:44.340]     }
[15:32:44.340]     else {
[15:32:44.340]         if (TRUE) {
[15:32:44.340]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:44.340]                 open = "w")
[15:32:44.340]         }
[15:32:44.340]         else {
[15:32:44.340]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:44.340]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:44.340]         }
[15:32:44.340]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:44.340]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:44.340]             base::sink(type = "output", split = FALSE)
[15:32:44.340]             base::close(...future.stdout)
[15:32:44.340]         }, add = TRUE)
[15:32:44.340]     }
[15:32:44.340]     ...future.frame <- base::sys.nframe()
[15:32:44.340]     ...future.conditions <- base::list()
[15:32:44.340]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:44.340]     if (FALSE) {
[15:32:44.340]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:44.340]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:44.340]     }
[15:32:44.340]     ...future.result <- base::tryCatch({
[15:32:44.340]         base::withCallingHandlers({
[15:32:44.340]             ...future.value <- base::withVisible(base::local({
[15:32:44.340]                 do.call(function(...) {
[15:32:44.340]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.340]                   if (!identical(...future.globals.maxSize.org, 
[15:32:44.340]                     ...future.globals.maxSize)) {
[15:32:44.340]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.340]                     on.exit(options(oopts), add = TRUE)
[15:32:44.340]                   }
[15:32:44.340]                   {
[15:32:44.340]                     lapply(seq_along(...future.elements_ii), 
[15:32:44.340]                       FUN = function(jj) {
[15:32:44.340]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.340]                         ...future.FUN(...future.X_jj, ...)
[15:32:44.340]                       })
[15:32:44.340]                   }
[15:32:44.340]                 }, args = future.call.arguments)
[15:32:44.340]             }))
[15:32:44.340]             future::FutureResult(value = ...future.value$value, 
[15:32:44.340]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:44.340]                   ...future.rng), globalenv = if (FALSE) 
[15:32:44.340]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:44.340]                     ...future.globalenv.names))
[15:32:44.340]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:44.340]         }, condition = base::local({
[15:32:44.340]             c <- base::c
[15:32:44.340]             inherits <- base::inherits
[15:32:44.340]             invokeRestart <- base::invokeRestart
[15:32:44.340]             length <- base::length
[15:32:44.340]             list <- base::list
[15:32:44.340]             seq.int <- base::seq.int
[15:32:44.340]             signalCondition <- base::signalCondition
[15:32:44.340]             sys.calls <- base::sys.calls
[15:32:44.340]             `[[` <- base::`[[`
[15:32:44.340]             `+` <- base::`+`
[15:32:44.340]             `<<-` <- base::`<<-`
[15:32:44.340]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:44.340]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:44.340]                   3L)]
[15:32:44.340]             }
[15:32:44.340]             function(cond) {
[15:32:44.340]                 is_error <- inherits(cond, "error")
[15:32:44.340]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:44.340]                   NULL)
[15:32:44.340]                 if (is_error) {
[15:32:44.340]                   sessionInformation <- function() {
[15:32:44.340]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:44.340]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:44.340]                       search = base::search(), system = base::Sys.info())
[15:32:44.340]                   }
[15:32:44.340]                   ...future.conditions[[length(...future.conditions) + 
[15:32:44.340]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:44.340]                     cond$call), session = sessionInformation(), 
[15:32:44.340]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:44.340]                   signalCondition(cond)
[15:32:44.340]                 }
[15:32:44.340]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:44.340]                 "immediateCondition"))) {
[15:32:44.340]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:44.340]                   ...future.conditions[[length(...future.conditions) + 
[15:32:44.340]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:44.340]                   if (TRUE && !signal) {
[15:32:44.340]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:44.340]                     {
[15:32:44.340]                       inherits <- base::inherits
[15:32:44.340]                       invokeRestart <- base::invokeRestart
[15:32:44.340]                       is.null <- base::is.null
[15:32:44.340]                       muffled <- FALSE
[15:32:44.340]                       if (inherits(cond, "message")) {
[15:32:44.340]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:44.340]                         if (muffled) 
[15:32:44.340]                           invokeRestart("muffleMessage")
[15:32:44.340]                       }
[15:32:44.340]                       else if (inherits(cond, "warning")) {
[15:32:44.340]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:44.340]                         if (muffled) 
[15:32:44.340]                           invokeRestart("muffleWarning")
[15:32:44.340]                       }
[15:32:44.340]                       else if (inherits(cond, "condition")) {
[15:32:44.340]                         if (!is.null(pattern)) {
[15:32:44.340]                           computeRestarts <- base::computeRestarts
[15:32:44.340]                           grepl <- base::grepl
[15:32:44.340]                           restarts <- computeRestarts(cond)
[15:32:44.340]                           for (restart in restarts) {
[15:32:44.340]                             name <- restart$name
[15:32:44.340]                             if (is.null(name)) 
[15:32:44.340]                               next
[15:32:44.340]                             if (!grepl(pattern, name)) 
[15:32:44.340]                               next
[15:32:44.340]                             invokeRestart(restart)
[15:32:44.340]                             muffled <- TRUE
[15:32:44.340]                             break
[15:32:44.340]                           }
[15:32:44.340]                         }
[15:32:44.340]                       }
[15:32:44.340]                       invisible(muffled)
[15:32:44.340]                     }
[15:32:44.340]                     muffleCondition(cond, pattern = "^muffle")
[15:32:44.340]                   }
[15:32:44.340]                 }
[15:32:44.340]                 else {
[15:32:44.340]                   if (TRUE) {
[15:32:44.340]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:44.340]                     {
[15:32:44.340]                       inherits <- base::inherits
[15:32:44.340]                       invokeRestart <- base::invokeRestart
[15:32:44.340]                       is.null <- base::is.null
[15:32:44.340]                       muffled <- FALSE
[15:32:44.340]                       if (inherits(cond, "message")) {
[15:32:44.340]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:44.340]                         if (muffled) 
[15:32:44.340]                           invokeRestart("muffleMessage")
[15:32:44.340]                       }
[15:32:44.340]                       else if (inherits(cond, "warning")) {
[15:32:44.340]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:44.340]                         if (muffled) 
[15:32:44.340]                           invokeRestart("muffleWarning")
[15:32:44.340]                       }
[15:32:44.340]                       else if (inherits(cond, "condition")) {
[15:32:44.340]                         if (!is.null(pattern)) {
[15:32:44.340]                           computeRestarts <- base::computeRestarts
[15:32:44.340]                           grepl <- base::grepl
[15:32:44.340]                           restarts <- computeRestarts(cond)
[15:32:44.340]                           for (restart in restarts) {
[15:32:44.340]                             name <- restart$name
[15:32:44.340]                             if (is.null(name)) 
[15:32:44.340]                               next
[15:32:44.340]                             if (!grepl(pattern, name)) 
[15:32:44.340]                               next
[15:32:44.340]                             invokeRestart(restart)
[15:32:44.340]                             muffled <- TRUE
[15:32:44.340]                             break
[15:32:44.340]                           }
[15:32:44.340]                         }
[15:32:44.340]                       }
[15:32:44.340]                       invisible(muffled)
[15:32:44.340]                     }
[15:32:44.340]                     muffleCondition(cond, pattern = "^muffle")
[15:32:44.340]                   }
[15:32:44.340]                 }
[15:32:44.340]             }
[15:32:44.340]         }))
[15:32:44.340]     }, error = function(ex) {
[15:32:44.340]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:44.340]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:44.340]                 ...future.rng), started = ...future.startTime, 
[15:32:44.340]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:44.340]             version = "1.8"), class = "FutureResult")
[15:32:44.340]     }, finally = {
[15:32:44.340]         if (!identical(...future.workdir, getwd())) 
[15:32:44.340]             setwd(...future.workdir)
[15:32:44.340]         {
[15:32:44.340]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:44.340]                 ...future.oldOptions$nwarnings <- NULL
[15:32:44.340]             }
[15:32:44.340]             base::options(...future.oldOptions)
[15:32:44.340]             if (.Platform$OS.type == "windows") {
[15:32:44.340]                 old_names <- names(...future.oldEnvVars)
[15:32:44.340]                 envs <- base::Sys.getenv()
[15:32:44.340]                 names <- names(envs)
[15:32:44.340]                 common <- intersect(names, old_names)
[15:32:44.340]                 added <- setdiff(names, old_names)
[15:32:44.340]                 removed <- setdiff(old_names, names)
[15:32:44.340]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:44.340]                   envs[common]]
[15:32:44.340]                 NAMES <- toupper(changed)
[15:32:44.340]                 args <- list()
[15:32:44.340]                 for (kk in seq_along(NAMES)) {
[15:32:44.340]                   name <- changed[[kk]]
[15:32:44.340]                   NAME <- NAMES[[kk]]
[15:32:44.340]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.340]                     next
[15:32:44.340]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:44.340]                 }
[15:32:44.340]                 NAMES <- toupper(added)
[15:32:44.340]                 for (kk in seq_along(NAMES)) {
[15:32:44.340]                   name <- added[[kk]]
[15:32:44.340]                   NAME <- NAMES[[kk]]
[15:32:44.340]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.340]                     next
[15:32:44.340]                   args[[name]] <- ""
[15:32:44.340]                 }
[15:32:44.340]                 NAMES <- toupper(removed)
[15:32:44.340]                 for (kk in seq_along(NAMES)) {
[15:32:44.340]                   name <- removed[[kk]]
[15:32:44.340]                   NAME <- NAMES[[kk]]
[15:32:44.340]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.340]                     next
[15:32:44.340]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:44.340]                 }
[15:32:44.340]                 if (length(args) > 0) 
[15:32:44.340]                   base::do.call(base::Sys.setenv, args = args)
[15:32:44.340]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:44.340]             }
[15:32:44.340]             else {
[15:32:44.340]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:44.340]             }
[15:32:44.340]             {
[15:32:44.340]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:44.340]                   0L) {
[15:32:44.340]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:44.340]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:44.340]                   base::options(opts)
[15:32:44.340]                 }
[15:32:44.340]                 {
[15:32:44.340]                   {
[15:32:44.340]                     NULL
[15:32:44.340]                     RNGkind("Mersenne-Twister")
[15:32:44.340]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:44.340]                       inherits = FALSE)
[15:32:44.340]                   }
[15:32:44.340]                   options(future.plan = NULL)
[15:32:44.340]                   if (is.na(NA_character_)) 
[15:32:44.340]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:44.340]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:44.340]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:44.340]                     .init = FALSE)
[15:32:44.340]                 }
[15:32:44.340]             }
[15:32:44.340]         }
[15:32:44.340]     })
[15:32:44.340]     if (TRUE) {
[15:32:44.340]         base::sink(type = "output", split = FALSE)
[15:32:44.340]         if (TRUE) {
[15:32:44.340]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:44.340]         }
[15:32:44.340]         else {
[15:32:44.340]             ...future.result["stdout"] <- base::list(NULL)
[15:32:44.340]         }
[15:32:44.340]         base::close(...future.stdout)
[15:32:44.340]         ...future.stdout <- NULL
[15:32:44.340]     }
[15:32:44.340]     ...future.result$conditions <- ...future.conditions
[15:32:44.340]     ...future.result$finished <- base::Sys.time()
[15:32:44.340]     ...future.result
[15:32:44.340] }
[15:32:44.348] assign_globals() ...
[15:32:44.349] List of 11
[15:32:44.349]  $ ...future.FUN            :function (x, ...)  
[15:32:44.349]  $ x_FUN                    :function (x)  
[15:32:44.349]  $ times                    : int 0
[15:32:44.349]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.349]  $ stop_if_not              :function (...)  
[15:32:44.349]  $ dim                      : NULL
[15:32:44.349]  $ valid_types              : chr [1:3] "logical" "integer" "double"
[15:32:44.349]  $ future.call.arguments    : list()
[15:32:44.349]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.349]  $ ...future.elements_ii    :List of 10
[15:32:44.349]   ..$ : int 1
[15:32:44.349]   ..$ : int 2
[15:32:44.349]   ..$ : int 3
[15:32:44.349]   ..$ : int 4
[15:32:44.349]   ..$ : int 5
[15:32:44.349]   ..$ : int 6
[15:32:44.349]   ..$ : int 7
[15:32:44.349]   ..$ : int 8
[15:32:44.349]   ..$ : int 9
[15:32:44.349]   ..$ : int 10
[15:32:44.349]  $ ...future.seeds_ii       : NULL
[15:32:44.349]  $ ...future.globals.maxSize: NULL
[15:32:44.349]  - attr(*, "where")=List of 11
[15:32:44.349]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:44.349]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:44.349]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:44.349]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:44.349]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:44.349]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:44.349]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:44.349]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:44.349]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:44.349]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:44.349]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:44.349]  - attr(*, "resolved")= logi FALSE
[15:32:44.349]  - attr(*, "total_size")= num 95472
[15:32:44.349]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.349]  - attr(*, "already-done")= logi TRUE
[15:32:44.370] - copied '...future.FUN' to environment
[15:32:44.370] - reassign environment for 'x_FUN'
[15:32:44.370] - copied 'x_FUN' to environment
[15:32:44.370] - copied 'times' to environment
[15:32:44.370] - copied 'stopf' to environment
[15:32:44.370] - copied 'stop_if_not' to environment
[15:32:44.371] - copied 'dim' to environment
[15:32:44.371] - copied 'valid_types' to environment
[15:32:44.371] - copied 'future.call.arguments' to environment
[15:32:44.371] - copied '...future.elements_ii' to environment
[15:32:44.371] - copied '...future.seeds_ii' to environment
[15:32:44.372] - copied '...future.globals.maxSize' to environment
[15:32:44.372] assign_globals() ... done
[15:32:44.373] plan(): Setting new future strategy stack:
[15:32:44.373] List of future strategies:
[15:32:44.373] 1. sequential:
[15:32:44.373]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.373]    - tweaked: FALSE
[15:32:44.373]    - call: NULL
[15:32:44.373] plan(): nbrOfWorkers() = 1
[15:32:44.375] plan(): Setting new future strategy stack:
[15:32:44.375] List of future strategies:
[15:32:44.375] 1. sequential:
[15:32:44.375]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.375]    - tweaked: FALSE
[15:32:44.375]    - call: plan(strategy)
[15:32:44.376] plan(): nbrOfWorkers() = 1
[15:32:44.376] SequentialFuture started (and completed)
[15:32:44.376] - Launch lazy future ... done
[15:32:44.377] run() for 'SequentialFuture' ... done
[15:32:44.377] Created future:
[15:32:44.377] SequentialFuture:
[15:32:44.377] Label: 'future_vapply-1'
[15:32:44.377] Expression:
[15:32:44.377] {
[15:32:44.377]     do.call(function(...) {
[15:32:44.377]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.377]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:44.377]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.377]             on.exit(options(oopts), add = TRUE)
[15:32:44.377]         }
[15:32:44.377]         {
[15:32:44.377]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:44.377]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.377]                 ...future.FUN(...future.X_jj, ...)
[15:32:44.377]             })
[15:32:44.377]         }
[15:32:44.377]     }, args = future.call.arguments)
[15:32:44.377] }
[15:32:44.377] Lazy evaluation: FALSE
[15:32:44.377] Asynchronous evaluation: FALSE
[15:32:44.377] Local evaluation: TRUE
[15:32:44.377] Environment: R_GlobalEnv
[15:32:44.377] Capture standard output: TRUE
[15:32:44.377] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:44.377] Globals: 11 objects totaling 93.78 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 1.16 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:44.377] Packages: 1 packages ('future.apply')
[15:32:44.377] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:44.377] Resolved: TRUE
[15:32:44.377] Value: 480 bytes of class 'list'
[15:32:44.377] Early signaling: FALSE
[15:32:44.377] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:44.377] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:44.380] Chunk #1 of 1 ... DONE
[15:32:44.380] Launching 1 futures (chunks) ... DONE
[15:32:44.381] Resolving 1 futures (chunks) ...
[15:32:44.381] resolve() on list ...
[15:32:44.381]  recursive: 0
[15:32:44.382]  length: 1
[15:32:44.382] 
[15:32:44.382] resolved() for 'SequentialFuture' ...
[15:32:44.382] - state: 'finished'
[15:32:44.383] - run: TRUE
[15:32:44.383] - result: 'FutureResult'
[15:32:44.384] resolved() for 'SequentialFuture' ... done
[15:32:44.384] Future #1
[15:32:44.384] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:44.385] - nx: 1
[15:32:44.385] - relay: TRUE
[15:32:44.385] - stdout: TRUE
[15:32:44.385] - signal: TRUE
[15:32:44.386] - resignal: FALSE
[15:32:44.386] - force: TRUE
[15:32:44.386] - relayed: [n=1] FALSE
[15:32:44.386] - queued futures: [n=1] FALSE
[15:32:44.386]  - until=1
[15:32:44.387]  - relaying element #1
[15:32:44.387] - relayed: [n=1] TRUE
[15:32:44.387] - queued futures: [n=1] TRUE
[15:32:44.387] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:44.388]  length: 0 (resolved future 1)
[15:32:44.388] Relaying remaining futures
[15:32:44.388] signalConditionsASAP(NULL, pos=0) ...
[15:32:44.388] - nx: 1
[15:32:44.388] - relay: TRUE
[15:32:44.389] - stdout: TRUE
[15:32:44.389] - signal: TRUE
[15:32:44.389] - resignal: FALSE
[15:32:44.389] - force: TRUE
[15:32:44.389] - relayed: [n=1] TRUE
[15:32:44.389] - queued futures: [n=1] TRUE
 - flush all
[15:32:44.390] - relayed: [n=1] TRUE
[15:32:44.390] - queued futures: [n=1] TRUE
[15:32:44.390] signalConditionsASAP(NULL, pos=0) ... done
[15:32:44.390] resolve() on list ... DONE
[15:32:44.391]  - Number of value chunks collected: 1
[15:32:44.391] Resolving 1 futures (chunks) ... DONE
[15:32:44.391] Reducing values from 1 chunks ...
[15:32:44.391]  - Number of values collected after concatenation: 10
[15:32:44.391]  - Number of values expected: 10
[15:32:44.391] Reducing values from 1 chunks ... DONE
[15:32:44.392] future_lapply() ... DONE
 num[0 , 1:10] 
 int[0 , 1:10] 
[15:32:44.393] future_lapply() ...
[15:32:44.397] Number of chunks: 1
[15:32:44.397] getGlobalsAndPackagesXApply() ...
[15:32:44.397]  - future.globals: TRUE
[15:32:44.397] getGlobalsAndPackages() ...
[15:32:44.397] Searching for globals...
[15:32:44.408] - globals found: [17] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'integer'
[15:32:44.408] Searching for globals ... DONE
[15:32:44.409] Resolving globals: FALSE
[15:32:44.410] The total size of the 7 globals is 93.16 KiB (95400 bytes)
[15:32:44.411] The total size of the 7 globals exported for future expression ('FUN()') is 93.16 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:44.411] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.411] - packages: [1] 'future.apply'
[15:32:44.411] getGlobalsAndPackages() ... DONE
[15:32:44.411]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.412]  - needed namespaces: [n=1] 'future.apply'
[15:32:44.412] Finding globals ... DONE
[15:32:44.412]  - use_args: TRUE
[15:32:44.412]  - Getting '...' globals ...
[15:32:44.413] resolve() on list ...
[15:32:44.413]  recursive: 0
[15:32:44.414]  length: 1
[15:32:44.414]  elements: '...'
[15:32:44.414]  length: 0 (resolved future 1)
[15:32:44.414] resolve() on list ... DONE
[15:32:44.415]    - '...' content: [n=0] 
[15:32:44.415] List of 1
[15:32:44.415]  $ ...: list()
[15:32:44.415]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.415]  - attr(*, "where")=List of 1
[15:32:44.415]   ..$ ...:<environment: 0x0000022d3e364b50> 
[15:32:44.415]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.415]  - attr(*, "resolved")= logi TRUE
[15:32:44.415]  - attr(*, "total_size")= num NA
[15:32:44.421]  - Getting '...' globals ... DONE
[15:32:44.421] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:44.422] List of 8
[15:32:44.422]  $ ...future.FUN:function (x, ...)  
[15:32:44.422]  $ x_FUN        :function (x)  
[15:32:44.422]  $ times        : int 0
[15:32:44.422]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.422]  $ stop_if_not  :function (...)  
[15:32:44.422]  $ dim          : NULL
[15:32:44.422]  $ valid_types  : chr [1:2] "logical" "integer"
[15:32:44.422]  $ ...          : list()
[15:32:44.422]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.422]  - attr(*, "where")=List of 8
[15:32:44.422]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:44.422]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:44.422]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:44.422]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:44.422]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:44.422]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:44.422]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:44.422]   ..$ ...          :<environment: 0x0000022d3e364b50> 
[15:32:44.422]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.422]  - attr(*, "resolved")= logi FALSE
[15:32:44.422]  - attr(*, "total_size")= num 95400
[15:32:44.430] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:44.430] getGlobalsAndPackagesXApply() ... DONE
[15:32:44.430] Number of futures (= number of chunks): 1
[15:32:44.431] Launching 1 futures (chunks) ...
[15:32:44.431] Chunk #1 of 1 ...
[15:32:44.431]  - Finding globals in 'X' for chunk #1 ...
[15:32:44.431] getGlobalsAndPackages() ...
[15:32:44.431] Searching for globals...
[15:32:44.432] 
[15:32:44.432] Searching for globals ... DONE
[15:32:44.432] - globals: [0] <none>
[15:32:44.432] getGlobalsAndPackages() ... DONE
[15:32:44.433]    + additional globals found: [n=0] 
[15:32:44.433]    + additional namespaces needed: [n=0] 
[15:32:44.433]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:44.433]  - seeds: <none>
[15:32:44.433]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.433] getGlobalsAndPackages() ...
[15:32:44.436] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.437] Resolving globals: FALSE
[15:32:44.437] Tweak future expression to call with '...' arguments ...
[15:32:44.437] {
[15:32:44.437]     do.call(function(...) {
[15:32:44.437]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.437]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:44.437]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.437]             on.exit(options(oopts), add = TRUE)
[15:32:44.437]         }
[15:32:44.437]         {
[15:32:44.437]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:44.437]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.437]                 ...future.FUN(...future.X_jj, ...)
[15:32:44.437]             })
[15:32:44.437]         }
[15:32:44.437]     }, args = future.call.arguments)
[15:32:44.437] }
[15:32:44.438] Tweak future expression to call with '...' arguments ... DONE
[15:32:44.439] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.440] - packages: [1] 'future.apply'
[15:32:44.440] getGlobalsAndPackages() ... DONE
[15:32:44.441] run() for 'Future' ...
[15:32:44.441] - state: 'created'
[15:32:44.442] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:44.442] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:44.443] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:44.443]   - Field: 'label'
[15:32:44.443]   - Field: 'local'
[15:32:44.444]   - Field: 'owner'
[15:32:44.444]   - Field: 'envir'
[15:32:44.444]   - Field: 'packages'
[15:32:44.445]   - Field: 'gc'
[15:32:44.445]   - Field: 'conditions'
[15:32:44.445]   - Field: 'expr'
[15:32:44.445]   - Field: 'uuid'
[15:32:44.446]   - Field: 'seed'
[15:32:44.446]   - Field: 'version'
[15:32:44.446]   - Field: 'result'
[15:32:44.447]   - Field: 'asynchronous'
[15:32:44.447]   - Field: 'calls'
[15:32:44.447]   - Field: 'globals'
[15:32:44.447]   - Field: 'stdout'
[15:32:44.448]   - Field: 'earlySignal'
[15:32:44.448]   - Field: 'lazy'
[15:32:44.448]   - Field: 'state'
[15:32:44.448] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:44.449] - Launch lazy future ...
[15:32:44.449] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:44.449] Packages needed by future strategies (n = 0): <none>
[15:32:44.450] {
[15:32:44.450]     {
[15:32:44.450]         {
[15:32:44.450]             ...future.startTime <- base::Sys.time()
[15:32:44.450]             {
[15:32:44.450]                 {
[15:32:44.450]                   {
[15:32:44.450]                     {
[15:32:44.450]                       base::local({
[15:32:44.450]                         has_future <- base::requireNamespace("future", 
[15:32:44.450]                           quietly = TRUE)
[15:32:44.450]                         if (has_future) {
[15:32:44.450]                           ns <- base::getNamespace("future")
[15:32:44.450]                           version <- ns[[".package"]][["version"]]
[15:32:44.450]                           if (is.null(version)) 
[15:32:44.450]                             version <- utils::packageVersion("future")
[15:32:44.450]                         }
[15:32:44.450]                         else {
[15:32:44.450]                           version <- NULL
[15:32:44.450]                         }
[15:32:44.450]                         if (!has_future || version < "1.8.0") {
[15:32:44.450]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:44.450]                             "", base::R.version$version.string), 
[15:32:44.450]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:44.450]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:44.450]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:44.450]                               "release", "version")], collapse = " "), 
[15:32:44.450]                             hostname = base::Sys.info()[["nodename"]])
[15:32:44.450]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:44.450]                             info)
[15:32:44.450]                           info <- base::paste(info, collapse = "; ")
[15:32:44.450]                           if (!has_future) {
[15:32:44.450]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:44.450]                               info)
[15:32:44.450]                           }
[15:32:44.450]                           else {
[15:32:44.450]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:44.450]                               info, version)
[15:32:44.450]                           }
[15:32:44.450]                           base::stop(msg)
[15:32:44.450]                         }
[15:32:44.450]                       })
[15:32:44.450]                     }
[15:32:44.450]                     base::local({
[15:32:44.450]                       for (pkg in "future.apply") {
[15:32:44.450]                         base::loadNamespace(pkg)
[15:32:44.450]                         base::library(pkg, character.only = TRUE)
[15:32:44.450]                       }
[15:32:44.450]                     })
[15:32:44.450]                   }
[15:32:44.450]                   ...future.strategy.old <- future::plan("list")
[15:32:44.450]                   options(future.plan = NULL)
[15:32:44.450]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:44.450]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:44.450]                 }
[15:32:44.450]                 ...future.workdir <- getwd()
[15:32:44.450]             }
[15:32:44.450]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:44.450]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:44.450]         }
[15:32:44.450]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:44.450]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:44.450]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:44.450]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:44.450]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:44.450]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:44.450]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:44.450]             base::names(...future.oldOptions))
[15:32:44.450]     }
[15:32:44.450]     if (FALSE) {
[15:32:44.450]     }
[15:32:44.450]     else {
[15:32:44.450]         if (TRUE) {
[15:32:44.450]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:44.450]                 open = "w")
[15:32:44.450]         }
[15:32:44.450]         else {
[15:32:44.450]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:44.450]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:44.450]         }
[15:32:44.450]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:44.450]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:44.450]             base::sink(type = "output", split = FALSE)
[15:32:44.450]             base::close(...future.stdout)
[15:32:44.450]         }, add = TRUE)
[15:32:44.450]     }
[15:32:44.450]     ...future.frame <- base::sys.nframe()
[15:32:44.450]     ...future.conditions <- base::list()
[15:32:44.450]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:44.450]     if (FALSE) {
[15:32:44.450]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:44.450]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:44.450]     }
[15:32:44.450]     ...future.result <- base::tryCatch({
[15:32:44.450]         base::withCallingHandlers({
[15:32:44.450]             ...future.value <- base::withVisible(base::local({
[15:32:44.450]                 do.call(function(...) {
[15:32:44.450]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.450]                   if (!identical(...future.globals.maxSize.org, 
[15:32:44.450]                     ...future.globals.maxSize)) {
[15:32:44.450]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.450]                     on.exit(options(oopts), add = TRUE)
[15:32:44.450]                   }
[15:32:44.450]                   {
[15:32:44.450]                     lapply(seq_along(...future.elements_ii), 
[15:32:44.450]                       FUN = function(jj) {
[15:32:44.450]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.450]                         ...future.FUN(...future.X_jj, ...)
[15:32:44.450]                       })
[15:32:44.450]                   }
[15:32:44.450]                 }, args = future.call.arguments)
[15:32:44.450]             }))
[15:32:44.450]             future::FutureResult(value = ...future.value$value, 
[15:32:44.450]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:44.450]                   ...future.rng), globalenv = if (FALSE) 
[15:32:44.450]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:44.450]                     ...future.globalenv.names))
[15:32:44.450]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:44.450]         }, condition = base::local({
[15:32:44.450]             c <- base::c
[15:32:44.450]             inherits <- base::inherits
[15:32:44.450]             invokeRestart <- base::invokeRestart
[15:32:44.450]             length <- base::length
[15:32:44.450]             list <- base::list
[15:32:44.450]             seq.int <- base::seq.int
[15:32:44.450]             signalCondition <- base::signalCondition
[15:32:44.450]             sys.calls <- base::sys.calls
[15:32:44.450]             `[[` <- base::`[[`
[15:32:44.450]             `+` <- base::`+`
[15:32:44.450]             `<<-` <- base::`<<-`
[15:32:44.450]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:44.450]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:44.450]                   3L)]
[15:32:44.450]             }
[15:32:44.450]             function(cond) {
[15:32:44.450]                 is_error <- inherits(cond, "error")
[15:32:44.450]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:44.450]                   NULL)
[15:32:44.450]                 if (is_error) {
[15:32:44.450]                   sessionInformation <- function() {
[15:32:44.450]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:44.450]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:44.450]                       search = base::search(), system = base::Sys.info())
[15:32:44.450]                   }
[15:32:44.450]                   ...future.conditions[[length(...future.conditions) + 
[15:32:44.450]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:44.450]                     cond$call), session = sessionInformation(), 
[15:32:44.450]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:44.450]                   signalCondition(cond)
[15:32:44.450]                 }
[15:32:44.450]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:44.450]                 "immediateCondition"))) {
[15:32:44.450]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:44.450]                   ...future.conditions[[length(...future.conditions) + 
[15:32:44.450]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:44.450]                   if (TRUE && !signal) {
[15:32:44.450]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:44.450]                     {
[15:32:44.450]                       inherits <- base::inherits
[15:32:44.450]                       invokeRestart <- base::invokeRestart
[15:32:44.450]                       is.null <- base::is.null
[15:32:44.450]                       muffled <- FALSE
[15:32:44.450]                       if (inherits(cond, "message")) {
[15:32:44.450]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:44.450]                         if (muffled) 
[15:32:44.450]                           invokeRestart("muffleMessage")
[15:32:44.450]                       }
[15:32:44.450]                       else if (inherits(cond, "warning")) {
[15:32:44.450]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:44.450]                         if (muffled) 
[15:32:44.450]                           invokeRestart("muffleWarning")
[15:32:44.450]                       }
[15:32:44.450]                       else if (inherits(cond, "condition")) {
[15:32:44.450]                         if (!is.null(pattern)) {
[15:32:44.450]                           computeRestarts <- base::computeRestarts
[15:32:44.450]                           grepl <- base::grepl
[15:32:44.450]                           restarts <- computeRestarts(cond)
[15:32:44.450]                           for (restart in restarts) {
[15:32:44.450]                             name <- restart$name
[15:32:44.450]                             if (is.null(name)) 
[15:32:44.450]                               next
[15:32:44.450]                             if (!grepl(pattern, name)) 
[15:32:44.450]                               next
[15:32:44.450]                             invokeRestart(restart)
[15:32:44.450]                             muffled <- TRUE
[15:32:44.450]                             break
[15:32:44.450]                           }
[15:32:44.450]                         }
[15:32:44.450]                       }
[15:32:44.450]                       invisible(muffled)
[15:32:44.450]                     }
[15:32:44.450]                     muffleCondition(cond, pattern = "^muffle")
[15:32:44.450]                   }
[15:32:44.450]                 }
[15:32:44.450]                 else {
[15:32:44.450]                   if (TRUE) {
[15:32:44.450]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:44.450]                     {
[15:32:44.450]                       inherits <- base::inherits
[15:32:44.450]                       invokeRestart <- base::invokeRestart
[15:32:44.450]                       is.null <- base::is.null
[15:32:44.450]                       muffled <- FALSE
[15:32:44.450]                       if (inherits(cond, "message")) {
[15:32:44.450]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:44.450]                         if (muffled) 
[15:32:44.450]                           invokeRestart("muffleMessage")
[15:32:44.450]                       }
[15:32:44.450]                       else if (inherits(cond, "warning")) {
[15:32:44.450]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:44.450]                         if (muffled) 
[15:32:44.450]                           invokeRestart("muffleWarning")
[15:32:44.450]                       }
[15:32:44.450]                       else if (inherits(cond, "condition")) {
[15:32:44.450]                         if (!is.null(pattern)) {
[15:32:44.450]                           computeRestarts <- base::computeRestarts
[15:32:44.450]                           grepl <- base::grepl
[15:32:44.450]                           restarts <- computeRestarts(cond)
[15:32:44.450]                           for (restart in restarts) {
[15:32:44.450]                             name <- restart$name
[15:32:44.450]                             if (is.null(name)) 
[15:32:44.450]                               next
[15:32:44.450]                             if (!grepl(pattern, name)) 
[15:32:44.450]                               next
[15:32:44.450]                             invokeRestart(restart)
[15:32:44.450]                             muffled <- TRUE
[15:32:44.450]                             break
[15:32:44.450]                           }
[15:32:44.450]                         }
[15:32:44.450]                       }
[15:32:44.450]                       invisible(muffled)
[15:32:44.450]                     }
[15:32:44.450]                     muffleCondition(cond, pattern = "^muffle")
[15:32:44.450]                   }
[15:32:44.450]                 }
[15:32:44.450]             }
[15:32:44.450]         }))
[15:32:44.450]     }, error = function(ex) {
[15:32:44.450]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:44.450]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:44.450]                 ...future.rng), started = ...future.startTime, 
[15:32:44.450]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:44.450]             version = "1.8"), class = "FutureResult")
[15:32:44.450]     }, finally = {
[15:32:44.450]         if (!identical(...future.workdir, getwd())) 
[15:32:44.450]             setwd(...future.workdir)
[15:32:44.450]         {
[15:32:44.450]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:44.450]                 ...future.oldOptions$nwarnings <- NULL
[15:32:44.450]             }
[15:32:44.450]             base::options(...future.oldOptions)
[15:32:44.450]             if (.Platform$OS.type == "windows") {
[15:32:44.450]                 old_names <- names(...future.oldEnvVars)
[15:32:44.450]                 envs <- base::Sys.getenv()
[15:32:44.450]                 names <- names(envs)
[15:32:44.450]                 common <- intersect(names, old_names)
[15:32:44.450]                 added <- setdiff(names, old_names)
[15:32:44.450]                 removed <- setdiff(old_names, names)
[15:32:44.450]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:44.450]                   envs[common]]
[15:32:44.450]                 NAMES <- toupper(changed)
[15:32:44.450]                 args <- list()
[15:32:44.450]                 for (kk in seq_along(NAMES)) {
[15:32:44.450]                   name <- changed[[kk]]
[15:32:44.450]                   NAME <- NAMES[[kk]]
[15:32:44.450]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.450]                     next
[15:32:44.450]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:44.450]                 }
[15:32:44.450]                 NAMES <- toupper(added)
[15:32:44.450]                 for (kk in seq_along(NAMES)) {
[15:32:44.450]                   name <- added[[kk]]
[15:32:44.450]                   NAME <- NAMES[[kk]]
[15:32:44.450]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.450]                     next
[15:32:44.450]                   args[[name]] <- ""
[15:32:44.450]                 }
[15:32:44.450]                 NAMES <- toupper(removed)
[15:32:44.450]                 for (kk in seq_along(NAMES)) {
[15:32:44.450]                   name <- removed[[kk]]
[15:32:44.450]                   NAME <- NAMES[[kk]]
[15:32:44.450]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.450]                     next
[15:32:44.450]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:44.450]                 }
[15:32:44.450]                 if (length(args) > 0) 
[15:32:44.450]                   base::do.call(base::Sys.setenv, args = args)
[15:32:44.450]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:44.450]             }
[15:32:44.450]             else {
[15:32:44.450]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:44.450]             }
[15:32:44.450]             {
[15:32:44.450]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:44.450]                   0L) {
[15:32:44.450]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:44.450]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:44.450]                   base::options(opts)
[15:32:44.450]                 }
[15:32:44.450]                 {
[15:32:44.450]                   {
[15:32:44.450]                     NULL
[15:32:44.450]                     RNGkind("Mersenne-Twister")
[15:32:44.450]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:44.450]                       inherits = FALSE)
[15:32:44.450]                   }
[15:32:44.450]                   options(future.plan = NULL)
[15:32:44.450]                   if (is.na(NA_character_)) 
[15:32:44.450]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:44.450]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:44.450]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:44.450]                     .init = FALSE)
[15:32:44.450]                 }
[15:32:44.450]             }
[15:32:44.450]         }
[15:32:44.450]     })
[15:32:44.450]     if (TRUE) {
[15:32:44.450]         base::sink(type = "output", split = FALSE)
[15:32:44.450]         if (TRUE) {
[15:32:44.450]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:44.450]         }
[15:32:44.450]         else {
[15:32:44.450]             ...future.result["stdout"] <- base::list(NULL)
[15:32:44.450]         }
[15:32:44.450]         base::close(...future.stdout)
[15:32:44.450]         ...future.stdout <- NULL
[15:32:44.450]     }
[15:32:44.450]     ...future.result$conditions <- ...future.conditions
[15:32:44.450]     ...future.result$finished <- base::Sys.time()
[15:32:44.450]     ...future.result
[15:32:44.450] }
[15:32:44.456] assign_globals() ...
[15:32:44.456] List of 11
[15:32:44.456]  $ ...future.FUN            :function (x, ...)  
[15:32:44.456]  $ x_FUN                    :function (x)  
[15:32:44.456]  $ times                    : int 0
[15:32:44.456]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.456]  $ stop_if_not              :function (...)  
[15:32:44.456]  $ dim                      : NULL
[15:32:44.456]  $ valid_types              : chr [1:2] "logical" "integer"
[15:32:44.456]  $ future.call.arguments    : list()
[15:32:44.456]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.456]  $ ...future.elements_ii    :List of 10
[15:32:44.456]   ..$ : int 1
[15:32:44.456]   ..$ : int 2
[15:32:44.456]   ..$ : int 3
[15:32:44.456]   ..$ : int 4
[15:32:44.456]   ..$ : int 5
[15:32:44.456]   ..$ : int 6
[15:32:44.456]   ..$ : int 7
[15:32:44.456]   ..$ : int 8
[15:32:44.456]   ..$ : int 9
[15:32:44.456]   ..$ : int 10
[15:32:44.456]  $ ...future.seeds_ii       : NULL
[15:32:44.456]  $ ...future.globals.maxSize: NULL
[15:32:44.456]  - attr(*, "where")=List of 11
[15:32:44.456]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:44.456]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:44.456]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:44.456]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:44.456]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:44.456]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:44.456]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:44.456]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:44.456]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:44.456]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:44.456]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:44.456]  - attr(*, "resolved")= logi FALSE
[15:32:44.456]  - attr(*, "total_size")= num 95400
[15:32:44.456]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.456]  - attr(*, "already-done")= logi TRUE
[15:32:44.482] - copied '...future.FUN' to environment
[15:32:44.482] - reassign environment for 'x_FUN'
[15:32:44.482] - copied 'x_FUN' to environment
[15:32:44.482] - copied 'times' to environment
[15:32:44.483] - copied 'stopf' to environment
[15:32:44.483] - copied 'stop_if_not' to environment
[15:32:44.483] - copied 'dim' to environment
[15:32:44.483] - copied 'valid_types' to environment
[15:32:44.483] - copied 'future.call.arguments' to environment
[15:32:44.484] - copied '...future.elements_ii' to environment
[15:32:44.484] - copied '...future.seeds_ii' to environment
[15:32:44.484] - copied '...future.globals.maxSize' to environment
[15:32:44.484] assign_globals() ... done
[15:32:44.485] plan(): Setting new future strategy stack:
[15:32:44.485] List of future strategies:
[15:32:44.485] 1. sequential:
[15:32:44.485]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.485]    - tweaked: FALSE
[15:32:44.485]    - call: NULL
[15:32:44.486] plan(): nbrOfWorkers() = 1
[15:32:44.489] plan(): Setting new future strategy stack:
[15:32:44.489] List of future strategies:
[15:32:44.489] 1. sequential:
[15:32:44.489]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.489]    - tweaked: FALSE
[15:32:44.489]    - call: plan(strategy)
[15:32:44.490] plan(): nbrOfWorkers() = 1
[15:32:44.491] SequentialFuture started (and completed)
[15:32:44.491] - Launch lazy future ... done
[15:32:44.491] run() for 'SequentialFuture' ... done
[15:32:44.492] Created future:
[15:32:44.492] SequentialFuture:
[15:32:44.492] Label: 'future_vapply-1'
[15:32:44.492] Expression:
[15:32:44.492] {
[15:32:44.492]     do.call(function(...) {
[15:32:44.492]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.492]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:44.492]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.492]             on.exit(options(oopts), add = TRUE)
[15:32:44.492]         }
[15:32:44.492]         {
[15:32:44.492]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:44.492]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.492]                 ...future.FUN(...future.X_jj, ...)
[15:32:44.492]             })
[15:32:44.492]         }
[15:32:44.492]     }, args = future.call.arguments)
[15:32:44.492] }
[15:32:44.492] Lazy evaluation: FALSE
[15:32:44.492] Asynchronous evaluation: FALSE
[15:32:44.492] Local evaluation: TRUE
[15:32:44.492] Environment: R_GlobalEnv
[15:32:44.492] Capture standard output: TRUE
[15:32:44.492] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:44.492] Globals: 11 objects totaling 93.71 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 1.16 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:44.492] Packages: 1 packages ('future.apply')
[15:32:44.492] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:44.492] Resolved: TRUE
[15:32:44.492] Value: 480 bytes of class 'list'
[15:32:44.492] Early signaling: FALSE
[15:32:44.492] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:44.492] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:44.495] Chunk #1 of 1 ... DONE
[15:32:44.496] Launching 1 futures (chunks) ... DONE
[15:32:44.496] Resolving 1 futures (chunks) ...
[15:32:44.496] resolve() on list ...
[15:32:44.497]  recursive: 0
[15:32:44.497]  length: 1
[15:32:44.497] 
[15:32:44.498] resolved() for 'SequentialFuture' ...
[15:32:44.498] - state: 'finished'
[15:32:44.498] - run: TRUE
[15:32:44.499] - result: 'FutureResult'
[15:32:44.499] resolved() for 'SequentialFuture' ... done
[15:32:44.499] Future #1
[15:32:44.500] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:44.500] - nx: 1
[15:32:44.501] - relay: TRUE
[15:32:44.501] - stdout: TRUE
[15:32:44.501] - signal: TRUE
[15:32:44.501] - resignal: FALSE
[15:32:44.502] - force: TRUE
[15:32:44.502] - relayed: [n=1] FALSE
[15:32:44.502] - queued futures: [n=1] FALSE
[15:32:44.503]  - until=1
[15:32:44.503]  - relaying element #1
[15:32:44.504] - relayed: [n=1] TRUE
[15:32:44.504] - queued futures: [n=1] TRUE
[15:32:44.504] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:44.504]  length: 0 (resolved future 1)
[15:32:44.505] Relaying remaining futures
[15:32:44.505] signalConditionsASAP(NULL, pos=0) ...
[15:32:44.505] - nx: 1
[15:32:44.506] - relay: TRUE
[15:32:44.506] - stdout: TRUE
[15:32:44.506] - signal: TRUE
[15:32:44.507] - resignal: FALSE
[15:32:44.507] - force: TRUE
[15:32:44.507] - relayed: [n=1] TRUE
[15:32:44.507] - queued futures: [n=1] TRUE
 - flush all
[15:32:44.508] - relayed: [n=1] TRUE
[15:32:44.508] - queued futures: [n=1] TRUE
[15:32:44.508] signalConditionsASAP(NULL, pos=0) ... done
[15:32:44.508] resolve() on list ... DONE
[15:32:44.508]  - Number of value chunks collected: 1
[15:32:44.509] Resolving 1 futures (chunks) ... DONE
[15:32:44.509] Reducing values from 1 chunks ...
[15:32:44.509]  - Number of values collected after concatenation: 10
[15:32:44.509]  - Number of values expected: 10
[15:32:44.509] Reducing values from 1 chunks ... DONE
[15:32:44.510] future_lapply() ... DONE
 int[0 , 1:10] 
 num [1:10] 1 1.41 1.73 2 2.24 ...
[15:32:44.511] future_lapply() ...
[15:32:44.516] Number of chunks: 1
[15:32:44.516] getGlobalsAndPackagesXApply() ...
[15:32:44.517]  - future.globals: TRUE
[15:32:44.517] getGlobalsAndPackages() ...
[15:32:44.517] Searching for globals...
[15:32:44.529] - globals found: [16] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types'
[15:32:44.530] Searching for globals ... DONE
[15:32:44.530] Resolving globals: FALSE
[15:32:44.532] The total size of the 7 globals is 92.12 KiB (94336 bytes)
[15:32:44.533] The total size of the 7 globals exported for future expression ('FUN()') is 92.12 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:44.534] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.534] - packages: [1] 'future.apply'
[15:32:44.534] getGlobalsAndPackages() ... DONE
[15:32:44.534]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.535]  - needed namespaces: [n=1] 'future.apply'
[15:32:44.535] Finding globals ... DONE
[15:32:44.535]  - use_args: TRUE
[15:32:44.536]  - Getting '...' globals ...
[15:32:44.536] resolve() on list ...
[15:32:44.537]  recursive: 0
[15:32:44.537]  length: 1
[15:32:44.537]  elements: '...'
[15:32:44.537]  length: 0 (resolved future 1)
[15:32:44.538] resolve() on list ... DONE
[15:32:44.538]    - '...' content: [n=0] 
[15:32:44.538] List of 1
[15:32:44.538]  $ ...: list()
[15:32:44.538]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.538]  - attr(*, "where")=List of 1
[15:32:44.538]   ..$ ...:<environment: 0x0000022d3dd744f8> 
[15:32:44.538]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.538]  - attr(*, "resolved")= logi TRUE
[15:32:44.538]  - attr(*, "total_size")= num NA
[15:32:44.544]  - Getting '...' globals ... DONE
[15:32:44.545] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:44.545] List of 8
[15:32:44.545]  $ ...future.FUN:function (x, ...)  
[15:32:44.545]  $ x_FUN        :function (x)  
[15:32:44.545]  $ times        : int 1
[15:32:44.545]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.545]  $ stop_if_not  :function (...)  
[15:32:44.545]  $ dim          : NULL
[15:32:44.545]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:44.545]  $ ...          : list()
[15:32:44.545]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.545]  - attr(*, "where")=List of 8
[15:32:44.545]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:44.545]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:44.545]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:44.545]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:44.545]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:44.545]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:44.545]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:44.545]   ..$ ...          :<environment: 0x0000022d3dd744f8> 
[15:32:44.545]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.545]  - attr(*, "resolved")= logi FALSE
[15:32:44.545]  - attr(*, "total_size")= num 94336
[15:32:44.557] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:44.557] getGlobalsAndPackagesXApply() ... DONE
[15:32:44.558] Number of futures (= number of chunks): 1
[15:32:44.558] Launching 1 futures (chunks) ...
[15:32:44.558] Chunk #1 of 1 ...
[15:32:44.559]  - Finding globals in 'X' for chunk #1 ...
[15:32:44.559] getGlobalsAndPackages() ...
[15:32:44.559] Searching for globals...
[15:32:44.560] 
[15:32:44.560] Searching for globals ... DONE
[15:32:44.561] - globals: [0] <none>
[15:32:44.561] getGlobalsAndPackages() ... DONE
[15:32:44.561]    + additional globals found: [n=0] 
[15:32:44.561]    + additional namespaces needed: [n=0] 
[15:32:44.562]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:44.562]  - seeds: <none>
[15:32:44.562]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.563] getGlobalsAndPackages() ...
[15:32:44.563] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.563] Resolving globals: FALSE
[15:32:44.563] Tweak future expression to call with '...' arguments ...
[15:32:44.564] {
[15:32:44.564]     do.call(function(...) {
[15:32:44.564]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.564]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:44.564]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.564]             on.exit(options(oopts), add = TRUE)
[15:32:44.564]         }
[15:32:44.564]         {
[15:32:44.564]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:44.564]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.564]                 ...future.FUN(...future.X_jj, ...)
[15:32:44.564]             })
[15:32:44.564]         }
[15:32:44.564]     }, args = future.call.arguments)
[15:32:44.564] }
[15:32:44.565] Tweak future expression to call with '...' arguments ... DONE
[15:32:44.566] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.566] - packages: [1] 'future.apply'
[15:32:44.567] getGlobalsAndPackages() ... DONE
[15:32:44.567] run() for 'Future' ...
[15:32:44.568] - state: 'created'
[15:32:44.568] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:44.573] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:44.574] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:44.574]   - Field: 'label'
[15:32:44.574]   - Field: 'local'
[15:32:44.575]   - Field: 'owner'
[15:32:44.575]   - Field: 'envir'
[15:32:44.575]   - Field: 'packages'
[15:32:44.576]   - Field: 'gc'
[15:32:44.576]   - Field: 'conditions'
[15:32:44.576]   - Field: 'expr'
[15:32:44.577]   - Field: 'uuid'
[15:32:44.577]   - Field: 'seed'
[15:32:44.577]   - Field: 'version'
[15:32:44.578]   - Field: 'result'
[15:32:44.578]   - Field: 'asynchronous'
[15:32:44.578]   - Field: 'calls'
[15:32:44.579]   - Field: 'globals'
[15:32:44.579]   - Field: 'stdout'
[15:32:44.579]   - Field: 'earlySignal'
[15:32:44.579]   - Field: 'lazy'
[15:32:44.580]   - Field: 'state'
[15:32:44.580] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:44.580] - Launch lazy future ...
[15:32:44.581] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:44.581] Packages needed by future strategies (n = 0): <none>
[15:32:44.583] {
[15:32:44.583]     {
[15:32:44.583]         {
[15:32:44.583]             ...future.startTime <- base::Sys.time()
[15:32:44.583]             {
[15:32:44.583]                 {
[15:32:44.583]                   {
[15:32:44.583]                     {
[15:32:44.583]                       base::local({
[15:32:44.583]                         has_future <- base::requireNamespace("future", 
[15:32:44.583]                           quietly = TRUE)
[15:32:44.583]                         if (has_future) {
[15:32:44.583]                           ns <- base::getNamespace("future")
[15:32:44.583]                           version <- ns[[".package"]][["version"]]
[15:32:44.583]                           if (is.null(version)) 
[15:32:44.583]                             version <- utils::packageVersion("future")
[15:32:44.583]                         }
[15:32:44.583]                         else {
[15:32:44.583]                           version <- NULL
[15:32:44.583]                         }
[15:32:44.583]                         if (!has_future || version < "1.8.0") {
[15:32:44.583]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:44.583]                             "", base::R.version$version.string), 
[15:32:44.583]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:44.583]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:44.583]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:44.583]                               "release", "version")], collapse = " "), 
[15:32:44.583]                             hostname = base::Sys.info()[["nodename"]])
[15:32:44.583]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:44.583]                             info)
[15:32:44.583]                           info <- base::paste(info, collapse = "; ")
[15:32:44.583]                           if (!has_future) {
[15:32:44.583]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:44.583]                               info)
[15:32:44.583]                           }
[15:32:44.583]                           else {
[15:32:44.583]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:44.583]                               info, version)
[15:32:44.583]                           }
[15:32:44.583]                           base::stop(msg)
[15:32:44.583]                         }
[15:32:44.583]                       })
[15:32:44.583]                     }
[15:32:44.583]                     base::local({
[15:32:44.583]                       for (pkg in "future.apply") {
[15:32:44.583]                         base::loadNamespace(pkg)
[15:32:44.583]                         base::library(pkg, character.only = TRUE)
[15:32:44.583]                       }
[15:32:44.583]                     })
[15:32:44.583]                   }
[15:32:44.583]                   ...future.strategy.old <- future::plan("list")
[15:32:44.583]                   options(future.plan = NULL)
[15:32:44.583]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:44.583]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:44.583]                 }
[15:32:44.583]                 ...future.workdir <- getwd()
[15:32:44.583]             }
[15:32:44.583]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:44.583]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:44.583]         }
[15:32:44.583]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:44.583]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:44.583]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:44.583]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:44.583]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:44.583]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:44.583]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:44.583]             base::names(...future.oldOptions))
[15:32:44.583]     }
[15:32:44.583]     if (FALSE) {
[15:32:44.583]     }
[15:32:44.583]     else {
[15:32:44.583]         if (TRUE) {
[15:32:44.583]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:44.583]                 open = "w")
[15:32:44.583]         }
[15:32:44.583]         else {
[15:32:44.583]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:44.583]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:44.583]         }
[15:32:44.583]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:44.583]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:44.583]             base::sink(type = "output", split = FALSE)
[15:32:44.583]             base::close(...future.stdout)
[15:32:44.583]         }, add = TRUE)
[15:32:44.583]     }
[15:32:44.583]     ...future.frame <- base::sys.nframe()
[15:32:44.583]     ...future.conditions <- base::list()
[15:32:44.583]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:44.583]     if (FALSE) {
[15:32:44.583]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:44.583]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:44.583]     }
[15:32:44.583]     ...future.result <- base::tryCatch({
[15:32:44.583]         base::withCallingHandlers({
[15:32:44.583]             ...future.value <- base::withVisible(base::local({
[15:32:44.583]                 do.call(function(...) {
[15:32:44.583]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.583]                   if (!identical(...future.globals.maxSize.org, 
[15:32:44.583]                     ...future.globals.maxSize)) {
[15:32:44.583]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.583]                     on.exit(options(oopts), add = TRUE)
[15:32:44.583]                   }
[15:32:44.583]                   {
[15:32:44.583]                     lapply(seq_along(...future.elements_ii), 
[15:32:44.583]                       FUN = function(jj) {
[15:32:44.583]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.583]                         ...future.FUN(...future.X_jj, ...)
[15:32:44.583]                       })
[15:32:44.583]                   }
[15:32:44.583]                 }, args = future.call.arguments)
[15:32:44.583]             }))
[15:32:44.583]             future::FutureResult(value = ...future.value$value, 
[15:32:44.583]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:44.583]                   ...future.rng), globalenv = if (FALSE) 
[15:32:44.583]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:44.583]                     ...future.globalenv.names))
[15:32:44.583]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:44.583]         }, condition = base::local({
[15:32:44.583]             c <- base::c
[15:32:44.583]             inherits <- base::inherits
[15:32:44.583]             invokeRestart <- base::invokeRestart
[15:32:44.583]             length <- base::length
[15:32:44.583]             list <- base::list
[15:32:44.583]             seq.int <- base::seq.int
[15:32:44.583]             signalCondition <- base::signalCondition
[15:32:44.583]             sys.calls <- base::sys.calls
[15:32:44.583]             `[[` <- base::`[[`
[15:32:44.583]             `+` <- base::`+`
[15:32:44.583]             `<<-` <- base::`<<-`
[15:32:44.583]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:44.583]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:44.583]                   3L)]
[15:32:44.583]             }
[15:32:44.583]             function(cond) {
[15:32:44.583]                 is_error <- inherits(cond, "error")
[15:32:44.583]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:44.583]                   NULL)
[15:32:44.583]                 if (is_error) {
[15:32:44.583]                   sessionInformation <- function() {
[15:32:44.583]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:44.583]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:44.583]                       search = base::search(), system = base::Sys.info())
[15:32:44.583]                   }
[15:32:44.583]                   ...future.conditions[[length(...future.conditions) + 
[15:32:44.583]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:44.583]                     cond$call), session = sessionInformation(), 
[15:32:44.583]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:44.583]                   signalCondition(cond)
[15:32:44.583]                 }
[15:32:44.583]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:44.583]                 "immediateCondition"))) {
[15:32:44.583]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:44.583]                   ...future.conditions[[length(...future.conditions) + 
[15:32:44.583]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:44.583]                   if (TRUE && !signal) {
[15:32:44.583]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:44.583]                     {
[15:32:44.583]                       inherits <- base::inherits
[15:32:44.583]                       invokeRestart <- base::invokeRestart
[15:32:44.583]                       is.null <- base::is.null
[15:32:44.583]                       muffled <- FALSE
[15:32:44.583]                       if (inherits(cond, "message")) {
[15:32:44.583]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:44.583]                         if (muffled) 
[15:32:44.583]                           invokeRestart("muffleMessage")
[15:32:44.583]                       }
[15:32:44.583]                       else if (inherits(cond, "warning")) {
[15:32:44.583]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:44.583]                         if (muffled) 
[15:32:44.583]                           invokeRestart("muffleWarning")
[15:32:44.583]                       }
[15:32:44.583]                       else if (inherits(cond, "condition")) {
[15:32:44.583]                         if (!is.null(pattern)) {
[15:32:44.583]                           computeRestarts <- base::computeRestarts
[15:32:44.583]                           grepl <- base::grepl
[15:32:44.583]                           restarts <- computeRestarts(cond)
[15:32:44.583]                           for (restart in restarts) {
[15:32:44.583]                             name <- restart$name
[15:32:44.583]                             if (is.null(name)) 
[15:32:44.583]                               next
[15:32:44.583]                             if (!grepl(pattern, name)) 
[15:32:44.583]                               next
[15:32:44.583]                             invokeRestart(restart)
[15:32:44.583]                             muffled <- TRUE
[15:32:44.583]                             break
[15:32:44.583]                           }
[15:32:44.583]                         }
[15:32:44.583]                       }
[15:32:44.583]                       invisible(muffled)
[15:32:44.583]                     }
[15:32:44.583]                     muffleCondition(cond, pattern = "^muffle")
[15:32:44.583]                   }
[15:32:44.583]                 }
[15:32:44.583]                 else {
[15:32:44.583]                   if (TRUE) {
[15:32:44.583]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:44.583]                     {
[15:32:44.583]                       inherits <- base::inherits
[15:32:44.583]                       invokeRestart <- base::invokeRestart
[15:32:44.583]                       is.null <- base::is.null
[15:32:44.583]                       muffled <- FALSE
[15:32:44.583]                       if (inherits(cond, "message")) {
[15:32:44.583]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:44.583]                         if (muffled) 
[15:32:44.583]                           invokeRestart("muffleMessage")
[15:32:44.583]                       }
[15:32:44.583]                       else if (inherits(cond, "warning")) {
[15:32:44.583]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:44.583]                         if (muffled) 
[15:32:44.583]                           invokeRestart("muffleWarning")
[15:32:44.583]                       }
[15:32:44.583]                       else if (inherits(cond, "condition")) {
[15:32:44.583]                         if (!is.null(pattern)) {
[15:32:44.583]                           computeRestarts <- base::computeRestarts
[15:32:44.583]                           grepl <- base::grepl
[15:32:44.583]                           restarts <- computeRestarts(cond)
[15:32:44.583]                           for (restart in restarts) {
[15:32:44.583]                             name <- restart$name
[15:32:44.583]                             if (is.null(name)) 
[15:32:44.583]                               next
[15:32:44.583]                             if (!grepl(pattern, name)) 
[15:32:44.583]                               next
[15:32:44.583]                             invokeRestart(restart)
[15:32:44.583]                             muffled <- TRUE
[15:32:44.583]                             break
[15:32:44.583]                           }
[15:32:44.583]                         }
[15:32:44.583]                       }
[15:32:44.583]                       invisible(muffled)
[15:32:44.583]                     }
[15:32:44.583]                     muffleCondition(cond, pattern = "^muffle")
[15:32:44.583]                   }
[15:32:44.583]                 }
[15:32:44.583]             }
[15:32:44.583]         }))
[15:32:44.583]     }, error = function(ex) {
[15:32:44.583]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:44.583]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:44.583]                 ...future.rng), started = ...future.startTime, 
[15:32:44.583]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:44.583]             version = "1.8"), class = "FutureResult")
[15:32:44.583]     }, finally = {
[15:32:44.583]         if (!identical(...future.workdir, getwd())) 
[15:32:44.583]             setwd(...future.workdir)
[15:32:44.583]         {
[15:32:44.583]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:44.583]                 ...future.oldOptions$nwarnings <- NULL
[15:32:44.583]             }
[15:32:44.583]             base::options(...future.oldOptions)
[15:32:44.583]             if (.Platform$OS.type == "windows") {
[15:32:44.583]                 old_names <- names(...future.oldEnvVars)
[15:32:44.583]                 envs <- base::Sys.getenv()
[15:32:44.583]                 names <- names(envs)
[15:32:44.583]                 common <- intersect(names, old_names)
[15:32:44.583]                 added <- setdiff(names, old_names)
[15:32:44.583]                 removed <- setdiff(old_names, names)
[15:32:44.583]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:44.583]                   envs[common]]
[15:32:44.583]                 NAMES <- toupper(changed)
[15:32:44.583]                 args <- list()
[15:32:44.583]                 for (kk in seq_along(NAMES)) {
[15:32:44.583]                   name <- changed[[kk]]
[15:32:44.583]                   NAME <- NAMES[[kk]]
[15:32:44.583]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.583]                     next
[15:32:44.583]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:44.583]                 }
[15:32:44.583]                 NAMES <- toupper(added)
[15:32:44.583]                 for (kk in seq_along(NAMES)) {
[15:32:44.583]                   name <- added[[kk]]
[15:32:44.583]                   NAME <- NAMES[[kk]]
[15:32:44.583]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.583]                     next
[15:32:44.583]                   args[[name]] <- ""
[15:32:44.583]                 }
[15:32:44.583]                 NAMES <- toupper(removed)
[15:32:44.583]                 for (kk in seq_along(NAMES)) {
[15:32:44.583]                   name <- removed[[kk]]
[15:32:44.583]                   NAME <- NAMES[[kk]]
[15:32:44.583]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.583]                     next
[15:32:44.583]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:44.583]                 }
[15:32:44.583]                 if (length(args) > 0) 
[15:32:44.583]                   base::do.call(base::Sys.setenv, args = args)
[15:32:44.583]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:44.583]             }
[15:32:44.583]             else {
[15:32:44.583]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:44.583]             }
[15:32:44.583]             {
[15:32:44.583]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:44.583]                   0L) {
[15:32:44.583]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:44.583]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:44.583]                   base::options(opts)
[15:32:44.583]                 }
[15:32:44.583]                 {
[15:32:44.583]                   {
[15:32:44.583]                     NULL
[15:32:44.583]                     RNGkind("Mersenne-Twister")
[15:32:44.583]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:44.583]                       inherits = FALSE)
[15:32:44.583]                   }
[15:32:44.583]                   options(future.plan = NULL)
[15:32:44.583]                   if (is.na(NA_character_)) 
[15:32:44.583]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:44.583]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:44.583]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:44.583]                     .init = FALSE)
[15:32:44.583]                 }
[15:32:44.583]             }
[15:32:44.583]         }
[15:32:44.583]     })
[15:32:44.583]     if (TRUE) {
[15:32:44.583]         base::sink(type = "output", split = FALSE)
[15:32:44.583]         if (TRUE) {
[15:32:44.583]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:44.583]         }
[15:32:44.583]         else {
[15:32:44.583]             ...future.result["stdout"] <- base::list(NULL)
[15:32:44.583]         }
[15:32:44.583]         base::close(...future.stdout)
[15:32:44.583]         ...future.stdout <- NULL
[15:32:44.583]     }
[15:32:44.583]     ...future.result$conditions <- ...future.conditions
[15:32:44.583]     ...future.result$finished <- base::Sys.time()
[15:32:44.583]     ...future.result
[15:32:44.583] }
[15:32:44.591] assign_globals() ...
[15:32:44.591] List of 11
[15:32:44.591]  $ ...future.FUN            :function (x, ...)  
[15:32:44.591]  $ x_FUN                    :function (x)  
[15:32:44.591]  $ times                    : int 1
[15:32:44.591]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.591]  $ stop_if_not              :function (...)  
[15:32:44.591]  $ dim                      : NULL
[15:32:44.591]  $ valid_types              : chr [1:3] "logical" "integer" "double"
[15:32:44.591]  $ future.call.arguments    : list()
[15:32:44.591]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.591]  $ ...future.elements_ii    :List of 10
[15:32:44.591]   ..$ : int 1
[15:32:44.591]   ..$ : int 2
[15:32:44.591]   ..$ : int 3
[15:32:44.591]   ..$ : int 4
[15:32:44.591]   ..$ : int 5
[15:32:44.591]   ..$ : int 6
[15:32:44.591]   ..$ : int 7
[15:32:44.591]   ..$ : int 8
[15:32:44.591]   ..$ : int 9
[15:32:44.591]   ..$ : int 10
[15:32:44.591]  $ ...future.seeds_ii       : NULL
[15:32:44.591]  $ ...future.globals.maxSize: NULL
[15:32:44.591]  - attr(*, "where")=List of 11
[15:32:44.591]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:44.591]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:44.591]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:44.591]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:44.591]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:44.591]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:44.591]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:44.591]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:44.591]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:44.591]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:44.591]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:44.591]  - attr(*, "resolved")= logi FALSE
[15:32:44.591]  - attr(*, "total_size")= num 94336
[15:32:44.591]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.591]  - attr(*, "already-done")= logi TRUE
[15:32:44.613] - copied '...future.FUN' to environment
[15:32:44.613] - copied 'x_FUN' to environment
[15:32:44.614] - copied 'times' to environment
[15:32:44.614] - copied 'stopf' to environment
[15:32:44.614] - copied 'stop_if_not' to environment
[15:32:44.614] - copied 'dim' to environment
[15:32:44.615] - copied 'valid_types' to environment
[15:32:44.615] - copied 'future.call.arguments' to environment
[15:32:44.615] - copied '...future.elements_ii' to environment
[15:32:44.616] - copied '...future.seeds_ii' to environment
[15:32:44.616] - copied '...future.globals.maxSize' to environment
[15:32:44.616] assign_globals() ... done
[15:32:44.622] plan(): Setting new future strategy stack:
[15:32:44.623] List of future strategies:
[15:32:44.623] 1. sequential:
[15:32:44.623]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.623]    - tweaked: FALSE
[15:32:44.623]    - call: NULL
[15:32:44.624] plan(): nbrOfWorkers() = 1
[15:32:44.626] plan(): Setting new future strategy stack:
[15:32:44.626] List of future strategies:
[15:32:44.626] 1. sequential:
[15:32:44.626]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.626]    - tweaked: FALSE
[15:32:44.626]    - call: plan(strategy)
[15:32:44.628] plan(): nbrOfWorkers() = 1
[15:32:44.628] SequentialFuture started (and completed)
[15:32:44.628] - Launch lazy future ... done
[15:32:44.629] run() for 'SequentialFuture' ... done
[15:32:44.629] Created future:
[15:32:44.629] SequentialFuture:
[15:32:44.629] Label: 'future_vapply-1'
[15:32:44.629] Expression:
[15:32:44.629] {
[15:32:44.629]     do.call(function(...) {
[15:32:44.629]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.629]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:44.629]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.629]             on.exit(options(oopts), add = TRUE)
[15:32:44.629]         }
[15:32:44.629]         {
[15:32:44.629]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:44.629]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.629]                 ...future.FUN(...future.X_jj, ...)
[15:32:44.629]             })
[15:32:44.629]         }
[15:32:44.629]     }, args = future.call.arguments)
[15:32:44.629] }
[15:32:44.629] Lazy evaluation: FALSE
[15:32:44.629] Asynchronous evaluation: FALSE
[15:32:44.629] Local evaluation: TRUE
[15:32:44.629] Environment: R_GlobalEnv
[15:32:44.629] Capture standard output: TRUE
[15:32:44.629] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:44.629] Globals: 11 objects totaling 92.67 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 56 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:44.629] Packages: 1 packages ('future.apply')
[15:32:44.629] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:44.629] Resolved: TRUE
[15:32:44.629] Value: 560 bytes of class 'list'
[15:32:44.629] Early signaling: FALSE
[15:32:44.629] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:44.629] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:44.632] Chunk #1 of 1 ... DONE
[15:32:44.633] Launching 1 futures (chunks) ... DONE
[15:32:44.633] Resolving 1 futures (chunks) ...
[15:32:44.633] resolve() on list ...
[15:32:44.634]  recursive: 0
[15:32:44.634]  length: 1
[15:32:44.634] 
[15:32:44.635] resolved() for 'SequentialFuture' ...
[15:32:44.635] - state: 'finished'
[15:32:44.635] - run: TRUE
[15:32:44.636] - result: 'FutureResult'
[15:32:44.636] resolved() for 'SequentialFuture' ... done
[15:32:44.636] Future #1
[15:32:44.637] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:44.637] - nx: 1
[15:32:44.637] - relay: TRUE
[15:32:44.638] - stdout: TRUE
[15:32:44.638] - signal: TRUE
[15:32:44.638] - resignal: FALSE
[15:32:44.638] - force: TRUE
[15:32:44.639] - relayed: [n=1] FALSE
[15:32:44.639] - queued futures: [n=1] FALSE
[15:32:44.639]  - until=1
[15:32:44.640]  - relaying element #1
[15:32:44.640] - relayed: [n=1] TRUE
[15:32:44.640] - queued futures: [n=1] TRUE
[15:32:44.641] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:44.641]  length: 0 (resolved future 1)
[15:32:44.641] Relaying remaining futures
[15:32:44.642] signalConditionsASAP(NULL, pos=0) ...
[15:32:44.642] - nx: 1
[15:32:44.642] - relay: TRUE
[15:32:44.643] - stdout: TRUE
[15:32:44.643] - signal: TRUE
[15:32:44.643] - resignal: FALSE
[15:32:44.644] - force: TRUE
[15:32:44.644] - relayed: [n=1] TRUE
[15:32:44.644] - queued futures: [n=1] TRUE
 - flush all
[15:32:44.645] - relayed: [n=1] TRUE
[15:32:44.645] - queued futures: [n=1] TRUE
[15:32:44.645] signalConditionsASAP(NULL, pos=0) ... done
[15:32:44.645] resolve() on list ... DONE
[15:32:44.646]  - Number of value chunks collected: 1
[15:32:44.646] Resolving 1 futures (chunks) ... DONE
[15:32:44.646] Reducing values from 1 chunks ...
[15:32:44.647]  - Number of values collected after concatenation: 10
[15:32:44.647]  - Number of values expected: 10
[15:32:44.647] Reducing values from 1 chunks ... DONE
[15:32:44.648] future_lapply() ... DONE
 num [1:10] 1 1.41 1.73 2 2.24 ...
 num [1:2, 1:10] 1 1 2 4 3 9 4 16 5 25 ...
[15:32:44.650] future_lapply() ...
[15:32:44.655] Number of chunks: 1
[15:32:44.655] getGlobalsAndPackagesXApply() ...
[15:32:44.655]  - future.globals: TRUE
[15:32:44.655] getGlobalsAndPackages() ...
[15:32:44.656] Searching for globals...
[15:32:44.665] - globals found: [18] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'c', '^'
[15:32:44.665] Searching for globals ... DONE
[15:32:44.665] Resolving globals: FALSE
[15:32:44.672] The total size of the 7 globals is 94.20 KiB (96456 bytes)
[15:32:44.673] The total size of the 7 globals exported for future expression ('FUN()') is 94.20 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:44.673] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.673] - packages: [1] 'future.apply'
[15:32:44.674] getGlobalsAndPackages() ... DONE
[15:32:44.674]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.674]  - needed namespaces: [n=1] 'future.apply'
[15:32:44.675] Finding globals ... DONE
[15:32:44.675]  - use_args: TRUE
[15:32:44.675]  - Getting '...' globals ...
[15:32:44.676] resolve() on list ...
[15:32:44.676]  recursive: 0
[15:32:44.677]  length: 1
[15:32:44.677]  elements: '...'
[15:32:44.677]  length: 0 (resolved future 1)
[15:32:44.677] resolve() on list ... DONE
[15:32:44.678]    - '...' content: [n=0] 
[15:32:44.678] List of 1
[15:32:44.678]  $ ...: list()
[15:32:44.678]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.678]  - attr(*, "where")=List of 1
[15:32:44.678]   ..$ ...:<environment: 0x0000022d3da07f08> 
[15:32:44.678]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.678]  - attr(*, "resolved")= logi TRUE
[15:32:44.678]  - attr(*, "total_size")= num NA
[15:32:44.683]  - Getting '...' globals ... DONE
[15:32:44.684] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:44.684] List of 8
[15:32:44.684]  $ ...future.FUN:function (x, ...)  
[15:32:44.684]  $ x_FUN        :function (x)  
[15:32:44.684]  $ times        : int 2
[15:32:44.684]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.684]  $ stop_if_not  :function (...)  
[15:32:44.684]  $ dim          : NULL
[15:32:44.684]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:44.684]  $ ...          : list()
[15:32:44.684]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.684]  - attr(*, "where")=List of 8
[15:32:44.684]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:44.684]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:44.684]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:44.684]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:44.684]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:44.684]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:44.684]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:44.684]   ..$ ...          :<environment: 0x0000022d3da07f08> 
[15:32:44.684]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.684]  - attr(*, "resolved")= logi FALSE
[15:32:44.684]  - attr(*, "total_size")= num 96456
[15:32:44.696] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:44.696] getGlobalsAndPackagesXApply() ... DONE
[15:32:44.697] Number of futures (= number of chunks): 1
[15:32:44.697] Launching 1 futures (chunks) ...
[15:32:44.697] Chunk #1 of 1 ...
[15:32:44.698]  - Finding globals in 'X' for chunk #1 ...
[15:32:44.698] getGlobalsAndPackages() ...
[15:32:44.698] Searching for globals...
[15:32:44.699] 
[15:32:44.699] Searching for globals ... DONE
[15:32:44.699] - globals: [0] <none>
[15:32:44.700] getGlobalsAndPackages() ... DONE
[15:32:44.700]    + additional globals found: [n=0] 
[15:32:44.700]    + additional namespaces needed: [n=0] 
[15:32:44.700]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:44.701]  - seeds: <none>
[15:32:44.701]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.701] getGlobalsAndPackages() ...
[15:32:44.702] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.702] Resolving globals: FALSE
[15:32:44.702] Tweak future expression to call with '...' arguments ...
[15:32:44.702] {
[15:32:44.702]     do.call(function(...) {
[15:32:44.702]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.702]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:44.702]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.702]             on.exit(options(oopts), add = TRUE)
[15:32:44.702]         }
[15:32:44.702]         {
[15:32:44.702]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:44.702]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.702]                 ...future.FUN(...future.X_jj, ...)
[15:32:44.702]             })
[15:32:44.702]         }
[15:32:44.702]     }, args = future.call.arguments)
[15:32:44.702] }
[15:32:44.703] Tweak future expression to call with '...' arguments ... DONE
[15:32:44.705] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.705] - packages: [1] 'future.apply'
[15:32:44.705] getGlobalsAndPackages() ... DONE
[15:32:44.706] run() for 'Future' ...
[15:32:44.706] - state: 'created'
[15:32:44.707] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:44.707] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:44.711] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:44.711]   - Field: 'label'
[15:32:44.711]   - Field: 'local'
[15:32:44.712]   - Field: 'owner'
[15:32:44.712]   - Field: 'envir'
[15:32:44.712]   - Field: 'packages'
[15:32:44.712]   - Field: 'gc'
[15:32:44.713]   - Field: 'conditions'
[15:32:44.713]   - Field: 'expr'
[15:32:44.713]   - Field: 'uuid'
[15:32:44.714]   - Field: 'seed'
[15:32:44.714]   - Field: 'version'
[15:32:44.714]   - Field: 'result'
[15:32:44.714]   - Field: 'asynchronous'
[15:32:44.715]   - Field: 'calls'
[15:32:44.715]   - Field: 'globals'
[15:32:44.715]   - Field: 'stdout'
[15:32:44.715]   - Field: 'earlySignal'
[15:32:44.716]   - Field: 'lazy'
[15:32:44.716]   - Field: 'state'
[15:32:44.716] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:44.717] - Launch lazy future ...
[15:32:44.717] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:44.718] Packages needed by future strategies (n = 0): <none>
[15:32:44.719] {
[15:32:44.719]     {
[15:32:44.719]         {
[15:32:44.719]             ...future.startTime <- base::Sys.time()
[15:32:44.719]             {
[15:32:44.719]                 {
[15:32:44.719]                   {
[15:32:44.719]                     {
[15:32:44.719]                       base::local({
[15:32:44.719]                         has_future <- base::requireNamespace("future", 
[15:32:44.719]                           quietly = TRUE)
[15:32:44.719]                         if (has_future) {
[15:32:44.719]                           ns <- base::getNamespace("future")
[15:32:44.719]                           version <- ns[[".package"]][["version"]]
[15:32:44.719]                           if (is.null(version)) 
[15:32:44.719]                             version <- utils::packageVersion("future")
[15:32:44.719]                         }
[15:32:44.719]                         else {
[15:32:44.719]                           version <- NULL
[15:32:44.719]                         }
[15:32:44.719]                         if (!has_future || version < "1.8.0") {
[15:32:44.719]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:44.719]                             "", base::R.version$version.string), 
[15:32:44.719]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:44.719]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:44.719]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:44.719]                               "release", "version")], collapse = " "), 
[15:32:44.719]                             hostname = base::Sys.info()[["nodename"]])
[15:32:44.719]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:44.719]                             info)
[15:32:44.719]                           info <- base::paste(info, collapse = "; ")
[15:32:44.719]                           if (!has_future) {
[15:32:44.719]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:44.719]                               info)
[15:32:44.719]                           }
[15:32:44.719]                           else {
[15:32:44.719]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:44.719]                               info, version)
[15:32:44.719]                           }
[15:32:44.719]                           base::stop(msg)
[15:32:44.719]                         }
[15:32:44.719]                       })
[15:32:44.719]                     }
[15:32:44.719]                     base::local({
[15:32:44.719]                       for (pkg in "future.apply") {
[15:32:44.719]                         base::loadNamespace(pkg)
[15:32:44.719]                         base::library(pkg, character.only = TRUE)
[15:32:44.719]                       }
[15:32:44.719]                     })
[15:32:44.719]                   }
[15:32:44.719]                   ...future.strategy.old <- future::plan("list")
[15:32:44.719]                   options(future.plan = NULL)
[15:32:44.719]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:44.719]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:44.719]                 }
[15:32:44.719]                 ...future.workdir <- getwd()
[15:32:44.719]             }
[15:32:44.719]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:44.719]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:44.719]         }
[15:32:44.719]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:44.719]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:44.719]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:44.719]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:44.719]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:44.719]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:44.719]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:44.719]             base::names(...future.oldOptions))
[15:32:44.719]     }
[15:32:44.719]     if (FALSE) {
[15:32:44.719]     }
[15:32:44.719]     else {
[15:32:44.719]         if (TRUE) {
[15:32:44.719]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:44.719]                 open = "w")
[15:32:44.719]         }
[15:32:44.719]         else {
[15:32:44.719]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:44.719]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:44.719]         }
[15:32:44.719]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:44.719]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:44.719]             base::sink(type = "output", split = FALSE)
[15:32:44.719]             base::close(...future.stdout)
[15:32:44.719]         }, add = TRUE)
[15:32:44.719]     }
[15:32:44.719]     ...future.frame <- base::sys.nframe()
[15:32:44.719]     ...future.conditions <- base::list()
[15:32:44.719]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:44.719]     if (FALSE) {
[15:32:44.719]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:44.719]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:44.719]     }
[15:32:44.719]     ...future.result <- base::tryCatch({
[15:32:44.719]         base::withCallingHandlers({
[15:32:44.719]             ...future.value <- base::withVisible(base::local({
[15:32:44.719]                 do.call(function(...) {
[15:32:44.719]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.719]                   if (!identical(...future.globals.maxSize.org, 
[15:32:44.719]                     ...future.globals.maxSize)) {
[15:32:44.719]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.719]                     on.exit(options(oopts), add = TRUE)
[15:32:44.719]                   }
[15:32:44.719]                   {
[15:32:44.719]                     lapply(seq_along(...future.elements_ii), 
[15:32:44.719]                       FUN = function(jj) {
[15:32:44.719]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.719]                         ...future.FUN(...future.X_jj, ...)
[15:32:44.719]                       })
[15:32:44.719]                   }
[15:32:44.719]                 }, args = future.call.arguments)
[15:32:44.719]             }))
[15:32:44.719]             future::FutureResult(value = ...future.value$value, 
[15:32:44.719]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:44.719]                   ...future.rng), globalenv = if (FALSE) 
[15:32:44.719]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:44.719]                     ...future.globalenv.names))
[15:32:44.719]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:44.719]         }, condition = base::local({
[15:32:44.719]             c <- base::c
[15:32:44.719]             inherits <- base::inherits
[15:32:44.719]             invokeRestart <- base::invokeRestart
[15:32:44.719]             length <- base::length
[15:32:44.719]             list <- base::list
[15:32:44.719]             seq.int <- base::seq.int
[15:32:44.719]             signalCondition <- base::signalCondition
[15:32:44.719]             sys.calls <- base::sys.calls
[15:32:44.719]             `[[` <- base::`[[`
[15:32:44.719]             `+` <- base::`+`
[15:32:44.719]             `<<-` <- base::`<<-`
[15:32:44.719]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:44.719]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:44.719]                   3L)]
[15:32:44.719]             }
[15:32:44.719]             function(cond) {
[15:32:44.719]                 is_error <- inherits(cond, "error")
[15:32:44.719]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:44.719]                   NULL)
[15:32:44.719]                 if (is_error) {
[15:32:44.719]                   sessionInformation <- function() {
[15:32:44.719]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:44.719]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:44.719]                       search = base::search(), system = base::Sys.info())
[15:32:44.719]                   }
[15:32:44.719]                   ...future.conditions[[length(...future.conditions) + 
[15:32:44.719]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:44.719]                     cond$call), session = sessionInformation(), 
[15:32:44.719]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:44.719]                   signalCondition(cond)
[15:32:44.719]                 }
[15:32:44.719]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:44.719]                 "immediateCondition"))) {
[15:32:44.719]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:44.719]                   ...future.conditions[[length(...future.conditions) + 
[15:32:44.719]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:44.719]                   if (TRUE && !signal) {
[15:32:44.719]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:44.719]                     {
[15:32:44.719]                       inherits <- base::inherits
[15:32:44.719]                       invokeRestart <- base::invokeRestart
[15:32:44.719]                       is.null <- base::is.null
[15:32:44.719]                       muffled <- FALSE
[15:32:44.719]                       if (inherits(cond, "message")) {
[15:32:44.719]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:44.719]                         if (muffled) 
[15:32:44.719]                           invokeRestart("muffleMessage")
[15:32:44.719]                       }
[15:32:44.719]                       else if (inherits(cond, "warning")) {
[15:32:44.719]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:44.719]                         if (muffled) 
[15:32:44.719]                           invokeRestart("muffleWarning")
[15:32:44.719]                       }
[15:32:44.719]                       else if (inherits(cond, "condition")) {
[15:32:44.719]                         if (!is.null(pattern)) {
[15:32:44.719]                           computeRestarts <- base::computeRestarts
[15:32:44.719]                           grepl <- base::grepl
[15:32:44.719]                           restarts <- computeRestarts(cond)
[15:32:44.719]                           for (restart in restarts) {
[15:32:44.719]                             name <- restart$name
[15:32:44.719]                             if (is.null(name)) 
[15:32:44.719]                               next
[15:32:44.719]                             if (!grepl(pattern, name)) 
[15:32:44.719]                               next
[15:32:44.719]                             invokeRestart(restart)
[15:32:44.719]                             muffled <- TRUE
[15:32:44.719]                             break
[15:32:44.719]                           }
[15:32:44.719]                         }
[15:32:44.719]                       }
[15:32:44.719]                       invisible(muffled)
[15:32:44.719]                     }
[15:32:44.719]                     muffleCondition(cond, pattern = "^muffle")
[15:32:44.719]                   }
[15:32:44.719]                 }
[15:32:44.719]                 else {
[15:32:44.719]                   if (TRUE) {
[15:32:44.719]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:44.719]                     {
[15:32:44.719]                       inherits <- base::inherits
[15:32:44.719]                       invokeRestart <- base::invokeRestart
[15:32:44.719]                       is.null <- base::is.null
[15:32:44.719]                       muffled <- FALSE
[15:32:44.719]                       if (inherits(cond, "message")) {
[15:32:44.719]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:44.719]                         if (muffled) 
[15:32:44.719]                           invokeRestart("muffleMessage")
[15:32:44.719]                       }
[15:32:44.719]                       else if (inherits(cond, "warning")) {
[15:32:44.719]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:44.719]                         if (muffled) 
[15:32:44.719]                           invokeRestart("muffleWarning")
[15:32:44.719]                       }
[15:32:44.719]                       else if (inherits(cond, "condition")) {
[15:32:44.719]                         if (!is.null(pattern)) {
[15:32:44.719]                           computeRestarts <- base::computeRestarts
[15:32:44.719]                           grepl <- base::grepl
[15:32:44.719]                           restarts <- computeRestarts(cond)
[15:32:44.719]                           for (restart in restarts) {
[15:32:44.719]                             name <- restart$name
[15:32:44.719]                             if (is.null(name)) 
[15:32:44.719]                               next
[15:32:44.719]                             if (!grepl(pattern, name)) 
[15:32:44.719]                               next
[15:32:44.719]                             invokeRestart(restart)
[15:32:44.719]                             muffled <- TRUE
[15:32:44.719]                             break
[15:32:44.719]                           }
[15:32:44.719]                         }
[15:32:44.719]                       }
[15:32:44.719]                       invisible(muffled)
[15:32:44.719]                     }
[15:32:44.719]                     muffleCondition(cond, pattern = "^muffle")
[15:32:44.719]                   }
[15:32:44.719]                 }
[15:32:44.719]             }
[15:32:44.719]         }))
[15:32:44.719]     }, error = function(ex) {
[15:32:44.719]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:44.719]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:44.719]                 ...future.rng), started = ...future.startTime, 
[15:32:44.719]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:44.719]             version = "1.8"), class = "FutureResult")
[15:32:44.719]     }, finally = {
[15:32:44.719]         if (!identical(...future.workdir, getwd())) 
[15:32:44.719]             setwd(...future.workdir)
[15:32:44.719]         {
[15:32:44.719]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:44.719]                 ...future.oldOptions$nwarnings <- NULL
[15:32:44.719]             }
[15:32:44.719]             base::options(...future.oldOptions)
[15:32:44.719]             if (.Platform$OS.type == "windows") {
[15:32:44.719]                 old_names <- names(...future.oldEnvVars)
[15:32:44.719]                 envs <- base::Sys.getenv()
[15:32:44.719]                 names <- names(envs)
[15:32:44.719]                 common <- intersect(names, old_names)
[15:32:44.719]                 added <- setdiff(names, old_names)
[15:32:44.719]                 removed <- setdiff(old_names, names)
[15:32:44.719]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:44.719]                   envs[common]]
[15:32:44.719]                 NAMES <- toupper(changed)
[15:32:44.719]                 args <- list()
[15:32:44.719]                 for (kk in seq_along(NAMES)) {
[15:32:44.719]                   name <- changed[[kk]]
[15:32:44.719]                   NAME <- NAMES[[kk]]
[15:32:44.719]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.719]                     next
[15:32:44.719]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:44.719]                 }
[15:32:44.719]                 NAMES <- toupper(added)
[15:32:44.719]                 for (kk in seq_along(NAMES)) {
[15:32:44.719]                   name <- added[[kk]]
[15:32:44.719]                   NAME <- NAMES[[kk]]
[15:32:44.719]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.719]                     next
[15:32:44.719]                   args[[name]] <- ""
[15:32:44.719]                 }
[15:32:44.719]                 NAMES <- toupper(removed)
[15:32:44.719]                 for (kk in seq_along(NAMES)) {
[15:32:44.719]                   name <- removed[[kk]]
[15:32:44.719]                   NAME <- NAMES[[kk]]
[15:32:44.719]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.719]                     next
[15:32:44.719]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:44.719]                 }
[15:32:44.719]                 if (length(args) > 0) 
[15:32:44.719]                   base::do.call(base::Sys.setenv, args = args)
[15:32:44.719]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:44.719]             }
[15:32:44.719]             else {
[15:32:44.719]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:44.719]             }
[15:32:44.719]             {
[15:32:44.719]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:44.719]                   0L) {
[15:32:44.719]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:44.719]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:44.719]                   base::options(opts)
[15:32:44.719]                 }
[15:32:44.719]                 {
[15:32:44.719]                   {
[15:32:44.719]                     NULL
[15:32:44.719]                     RNGkind("Mersenne-Twister")
[15:32:44.719]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:44.719]                       inherits = FALSE)
[15:32:44.719]                   }
[15:32:44.719]                   options(future.plan = NULL)
[15:32:44.719]                   if (is.na(NA_character_)) 
[15:32:44.719]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:44.719]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:44.719]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:44.719]                     .init = FALSE)
[15:32:44.719]                 }
[15:32:44.719]             }
[15:32:44.719]         }
[15:32:44.719]     })
[15:32:44.719]     if (TRUE) {
[15:32:44.719]         base::sink(type = "output", split = FALSE)
[15:32:44.719]         if (TRUE) {
[15:32:44.719]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:44.719]         }
[15:32:44.719]         else {
[15:32:44.719]             ...future.result["stdout"] <- base::list(NULL)
[15:32:44.719]         }
[15:32:44.719]         base::close(...future.stdout)
[15:32:44.719]         ...future.stdout <- NULL
[15:32:44.719]     }
[15:32:44.719]     ...future.result$conditions <- ...future.conditions
[15:32:44.719]     ...future.result$finished <- base::Sys.time()
[15:32:44.719]     ...future.result
[15:32:44.719] }
[15:32:44.726] assign_globals() ...
[15:32:44.726] List of 11
[15:32:44.726]  $ ...future.FUN            :function (x, ...)  
[15:32:44.726]  $ x_FUN                    :function (x)  
[15:32:44.726]  $ times                    : int 2
[15:32:44.726]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.726]  $ stop_if_not              :function (...)  
[15:32:44.726]  $ dim                      : NULL
[15:32:44.726]  $ valid_types              : chr [1:3] "logical" "integer" "double"
[15:32:44.726]  $ future.call.arguments    : list()
[15:32:44.726]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.726]  $ ...future.elements_ii    :List of 10
[15:32:44.726]   ..$ : int 1
[15:32:44.726]   ..$ : int 2
[15:32:44.726]   ..$ : int 3
[15:32:44.726]   ..$ : int 4
[15:32:44.726]   ..$ : int 5
[15:32:44.726]   ..$ : int 6
[15:32:44.726]   ..$ : int 7
[15:32:44.726]   ..$ : int 8
[15:32:44.726]   ..$ : int 9
[15:32:44.726]   ..$ : int 10
[15:32:44.726]  $ ...future.seeds_ii       : NULL
[15:32:44.726]  $ ...future.globals.maxSize: NULL
[15:32:44.726]  - attr(*, "where")=List of 11
[15:32:44.726]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:44.726]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:44.726]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:44.726]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:44.726]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:44.726]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:44.726]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:44.726]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:44.726]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:44.726]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:44.726]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:44.726]  - attr(*, "resolved")= logi FALSE
[15:32:44.726]  - attr(*, "total_size")= num 96456
[15:32:44.726]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.726]  - attr(*, "already-done")= logi TRUE
[15:32:44.745] - copied '...future.FUN' to environment
[15:32:44.745] - reassign environment for 'x_FUN'
[15:32:44.746] - copied 'x_FUN' to environment
[15:32:44.746] - copied 'times' to environment
[15:32:44.746] - copied 'stopf' to environment
[15:32:44.746] - copied 'stop_if_not' to environment
[15:32:44.747] - copied 'dim' to environment
[15:32:44.747] - copied 'valid_types' to environment
[15:32:44.747] - copied 'future.call.arguments' to environment
[15:32:44.747] - copied '...future.elements_ii' to environment
[15:32:44.747] - copied '...future.seeds_ii' to environment
[15:32:44.748] - copied '...future.globals.maxSize' to environment
[15:32:44.748] assign_globals() ... done
[15:32:44.807] plan(): Setting new future strategy stack:
[15:32:44.807] List of future strategies:
[15:32:44.807] 1. sequential:
[15:32:44.807]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.807]    - tweaked: FALSE
[15:32:44.807]    - call: NULL
[15:32:44.808] plan(): nbrOfWorkers() = 1
[15:32:44.810] plan(): Setting new future strategy stack:
[15:32:44.810] List of future strategies:
[15:32:44.810] 1. sequential:
[15:32:44.810]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.810]    - tweaked: FALSE
[15:32:44.810]    - call: plan(strategy)
[15:32:44.811] plan(): nbrOfWorkers() = 1
[15:32:44.812] SequentialFuture started (and completed)
[15:32:44.812] - Launch lazy future ... done
[15:32:44.812] run() for 'SequentialFuture' ... done
[15:32:44.812] Created future:
[15:32:44.813] SequentialFuture:
[15:32:44.813] Label: 'future_vapply-1'
[15:32:44.813] Expression:
[15:32:44.813] {
[15:32:44.813]     do.call(function(...) {
[15:32:44.813]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.813]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:44.813]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.813]             on.exit(options(oopts), add = TRUE)
[15:32:44.813]         }
[15:32:44.813]         {
[15:32:44.813]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:44.813]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.813]                 ...future.FUN(...future.X_jj, ...)
[15:32:44.813]             })
[15:32:44.813]         }
[15:32:44.813]     }, args = future.call.arguments)
[15:32:44.813] }
[15:32:44.813] Lazy evaluation: FALSE
[15:32:44.813] Asynchronous evaluation: FALSE
[15:32:44.813] Local evaluation: TRUE
[15:32:44.813] Environment: R_GlobalEnv
[15:32:44.813] Capture standard output: TRUE
[15:32:44.813] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:44.813] Globals: 11 objects totaling 94.74 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 2.12 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:44.813] Packages: 1 packages ('future.apply')
[15:32:44.813] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:44.813] Resolved: TRUE
[15:32:44.813] Value: 640 bytes of class 'list'
[15:32:44.813] Early signaling: FALSE
[15:32:44.813] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:44.813] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:44.815] Chunk #1 of 1 ... DONE
[15:32:44.816] Launching 1 futures (chunks) ... DONE
[15:32:44.816] Resolving 1 futures (chunks) ...
[15:32:44.816] resolve() on list ...
[15:32:44.817]  recursive: 0
[15:32:44.817]  length: 1
[15:32:44.817] 
[15:32:44.818] resolved() for 'SequentialFuture' ...
[15:32:44.818] - state: 'finished'
[15:32:44.818] - run: TRUE
[15:32:44.818] - result: 'FutureResult'
[15:32:44.819] resolved() for 'SequentialFuture' ... done
[15:32:44.819] Future #1
[15:32:44.820] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:44.820] - nx: 1
[15:32:44.820] - relay: TRUE
[15:32:44.820] - stdout: TRUE
[15:32:44.821] - signal: TRUE
[15:32:44.821] - resignal: FALSE
[15:32:44.821] - force: TRUE
[15:32:44.822] - relayed: [n=1] FALSE
[15:32:44.822] - queued futures: [n=1] FALSE
[15:32:44.822]  - until=1
[15:32:44.822]  - relaying element #1
[15:32:44.823] - relayed: [n=1] TRUE
[15:32:44.823] - queued futures: [n=1] TRUE
[15:32:44.824] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:44.824]  length: 0 (resolved future 1)
[15:32:44.824] Relaying remaining futures
[15:32:44.824] signalConditionsASAP(NULL, pos=0) ...
[15:32:44.825] - nx: 1
[15:32:44.825] - relay: TRUE
[15:32:44.825] - stdout: TRUE
[15:32:44.825] - signal: TRUE
[15:32:44.826] - resignal: FALSE
[15:32:44.826] - force: TRUE
[15:32:44.826] - relayed: [n=1] TRUE
[15:32:44.827] - queued futures: [n=1] TRUE
 - flush all
[15:32:44.827] - relayed: [n=1] TRUE
[15:32:44.827] - queued futures: [n=1] TRUE
[15:32:44.828] signalConditionsASAP(NULL, pos=0) ... done
[15:32:44.828] resolve() on list ... DONE
[15:32:44.828]  - Number of value chunks collected: 1
[15:32:44.829] Resolving 1 futures (chunks) ... DONE
[15:32:44.829] Reducing values from 1 chunks ...
[15:32:44.829]  - Number of values collected after concatenation: 10
[15:32:44.829]  - Number of values expected: 10
[15:32:44.830] Reducing values from 1 chunks ... DONE
[15:32:44.830] future_lapply() ... DONE
 num [1:2, 1:10] 1 1 2 4 3 9 4 16 5 25 ...
 int [1:2, 1:2, 1:10] 1 1 1 1 2 2 2 2 3 3 ...
[15:32:44.832] future_lapply() ...
[15:32:44.836] Number of chunks: 1
[15:32:44.837] getGlobalsAndPackagesXApply() ...
[15:32:44.837]  - future.globals: TRUE
[15:32:44.837] getGlobalsAndPackages() ...
[15:32:44.838] Searching for globals...
[15:32:44.846] - globals found: [17] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'matrix'
[15:32:44.846] Searching for globals ... DONE
[15:32:44.846] Resolving globals: FALSE
[15:32:44.848] The total size of the 7 globals is 94.95 KiB (97232 bytes)
[15:32:44.849] The total size of the 7 globals exported for future expression ('FUN()') is 94.95 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:44.850] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.850] - packages: [1] 'future.apply'
[15:32:44.851] getGlobalsAndPackages() ... DONE
[15:32:44.851]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.851]  - needed namespaces: [n=1] 'future.apply'
[15:32:44.851] Finding globals ... DONE
[15:32:44.852]  - use_args: TRUE
[15:32:44.852]  - Getting '...' globals ...
[15:32:44.856] resolve() on list ...
[15:32:44.856]  recursive: 0
[15:32:44.857]  length: 1
[15:32:44.857]  elements: '...'
[15:32:44.858]  length: 0 (resolved future 1)
[15:32:44.858] resolve() on list ... DONE
[15:32:44.858]    - '...' content: [n=0] 
[15:32:44.859] List of 1
[15:32:44.859]  $ ...: list()
[15:32:44.859]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.859]  - attr(*, "where")=List of 1
[15:32:44.859]   ..$ ...:<environment: 0x0000022d3c7a1a40> 
[15:32:44.859]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.859]  - attr(*, "resolved")= logi TRUE
[15:32:44.859]  - attr(*, "total_size")= num NA
[15:32:44.866]  - Getting '...' globals ... DONE
[15:32:44.866] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:44.866] List of 8
[15:32:44.866]  $ ...future.FUN:function (x, ...)  
[15:32:44.866]  $ x_FUN        :function (x)  
[15:32:44.866]  $ times        : int 4
[15:32:44.866]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.866]  $ stop_if_not  :function (...)  
[15:32:44.866]  $ dim          : int [1:2] 2 2
[15:32:44.866]  $ valid_types  : chr [1:2] "logical" "integer"
[15:32:44.866]  $ ...          : list()
[15:32:44.866]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.866]  - attr(*, "where")=List of 8
[15:32:44.866]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:44.866]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:44.866]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:44.866]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:44.866]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:44.866]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:44.866]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:44.866]   ..$ ...          :<environment: 0x0000022d3c7a1a40> 
[15:32:44.866]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.866]  - attr(*, "resolved")= logi FALSE
[15:32:44.866]  - attr(*, "total_size")= num 97232
[15:32:44.878] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:44.879] getGlobalsAndPackagesXApply() ... DONE
[15:32:44.879] Number of futures (= number of chunks): 1
[15:32:44.879] Launching 1 futures (chunks) ...
[15:32:44.880] Chunk #1 of 1 ...
[15:32:44.880]  - Finding globals in 'X' for chunk #1 ...
[15:32:44.880] getGlobalsAndPackages() ...
[15:32:44.881] Searching for globals...
[15:32:44.881] 
[15:32:44.882] Searching for globals ... DONE
[15:32:44.882] - globals: [0] <none>
[15:32:44.882] getGlobalsAndPackages() ... DONE
[15:32:44.882]    + additional globals found: [n=0] 
[15:32:44.883]    + additional namespaces needed: [n=0] 
[15:32:44.883]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:44.883]  - seeds: <none>
[15:32:44.884]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.884] getGlobalsAndPackages() ...
[15:32:44.884] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.885] Resolving globals: FALSE
[15:32:44.885] Tweak future expression to call with '...' arguments ...
[15:32:44.885] {
[15:32:44.885]     do.call(function(...) {
[15:32:44.885]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.885]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:44.885]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.885]             on.exit(options(oopts), add = TRUE)
[15:32:44.885]         }
[15:32:44.885]         {
[15:32:44.885]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:44.885]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.885]                 ...future.FUN(...future.X_jj, ...)
[15:32:44.885]             })
[15:32:44.885]         }
[15:32:44.885]     }, args = future.call.arguments)
[15:32:44.885] }
[15:32:44.886] Tweak future expression to call with '...' arguments ... DONE
[15:32:44.887] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:44.887] - packages: [1] 'future.apply'
[15:32:44.888] getGlobalsAndPackages() ... DONE
[15:32:44.888] run() for 'Future' ...
[15:32:44.889] - state: 'created'
[15:32:44.889] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:44.890] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:44.890] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:44.890]   - Field: 'label'
[15:32:44.891]   - Field: 'local'
[15:32:44.891]   - Field: 'owner'
[15:32:44.891]   - Field: 'envir'
[15:32:44.892]   - Field: 'packages'
[15:32:44.892]   - Field: 'gc'
[15:32:44.892]   - Field: 'conditions'
[15:32:44.892]   - Field: 'expr'
[15:32:44.893]   - Field: 'uuid'
[15:32:44.893]   - Field: 'seed'
[15:32:44.893]   - Field: 'version'
[15:32:44.894]   - Field: 'result'
[15:32:44.894]   - Field: 'asynchronous'
[15:32:44.894]   - Field: 'calls'
[15:32:44.895]   - Field: 'globals'
[15:32:44.895]   - Field: 'stdout'
[15:32:44.895]   - Field: 'earlySignal'
[15:32:44.896]   - Field: 'lazy'
[15:32:44.896]   - Field: 'state'
[15:32:44.896] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:44.897] - Launch lazy future ...
[15:32:44.897] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:44.898] Packages needed by future strategies (n = 0): <none>
[15:32:44.899] {
[15:32:44.899]     {
[15:32:44.899]         {
[15:32:44.899]             ...future.startTime <- base::Sys.time()
[15:32:44.899]             {
[15:32:44.899]                 {
[15:32:44.899]                   {
[15:32:44.899]                     {
[15:32:44.899]                       base::local({
[15:32:44.899]                         has_future <- base::requireNamespace("future", 
[15:32:44.899]                           quietly = TRUE)
[15:32:44.899]                         if (has_future) {
[15:32:44.899]                           ns <- base::getNamespace("future")
[15:32:44.899]                           version <- ns[[".package"]][["version"]]
[15:32:44.899]                           if (is.null(version)) 
[15:32:44.899]                             version <- utils::packageVersion("future")
[15:32:44.899]                         }
[15:32:44.899]                         else {
[15:32:44.899]                           version <- NULL
[15:32:44.899]                         }
[15:32:44.899]                         if (!has_future || version < "1.8.0") {
[15:32:44.899]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:44.899]                             "", base::R.version$version.string), 
[15:32:44.899]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:44.899]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:44.899]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:44.899]                               "release", "version")], collapse = " "), 
[15:32:44.899]                             hostname = base::Sys.info()[["nodename"]])
[15:32:44.899]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:44.899]                             info)
[15:32:44.899]                           info <- base::paste(info, collapse = "; ")
[15:32:44.899]                           if (!has_future) {
[15:32:44.899]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:44.899]                               info)
[15:32:44.899]                           }
[15:32:44.899]                           else {
[15:32:44.899]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:44.899]                               info, version)
[15:32:44.899]                           }
[15:32:44.899]                           base::stop(msg)
[15:32:44.899]                         }
[15:32:44.899]                       })
[15:32:44.899]                     }
[15:32:44.899]                     base::local({
[15:32:44.899]                       for (pkg in "future.apply") {
[15:32:44.899]                         base::loadNamespace(pkg)
[15:32:44.899]                         base::library(pkg, character.only = TRUE)
[15:32:44.899]                       }
[15:32:44.899]                     })
[15:32:44.899]                   }
[15:32:44.899]                   ...future.strategy.old <- future::plan("list")
[15:32:44.899]                   options(future.plan = NULL)
[15:32:44.899]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:44.899]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:44.899]                 }
[15:32:44.899]                 ...future.workdir <- getwd()
[15:32:44.899]             }
[15:32:44.899]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:44.899]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:44.899]         }
[15:32:44.899]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:44.899]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:44.899]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:44.899]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:44.899]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:44.899]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:44.899]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:44.899]             base::names(...future.oldOptions))
[15:32:44.899]     }
[15:32:44.899]     if (FALSE) {
[15:32:44.899]     }
[15:32:44.899]     else {
[15:32:44.899]         if (TRUE) {
[15:32:44.899]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:44.899]                 open = "w")
[15:32:44.899]         }
[15:32:44.899]         else {
[15:32:44.899]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:44.899]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:44.899]         }
[15:32:44.899]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:44.899]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:44.899]             base::sink(type = "output", split = FALSE)
[15:32:44.899]             base::close(...future.stdout)
[15:32:44.899]         }, add = TRUE)
[15:32:44.899]     }
[15:32:44.899]     ...future.frame <- base::sys.nframe()
[15:32:44.899]     ...future.conditions <- base::list()
[15:32:44.899]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:44.899]     if (FALSE) {
[15:32:44.899]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:44.899]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:44.899]     }
[15:32:44.899]     ...future.result <- base::tryCatch({
[15:32:44.899]         base::withCallingHandlers({
[15:32:44.899]             ...future.value <- base::withVisible(base::local({
[15:32:44.899]                 do.call(function(...) {
[15:32:44.899]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.899]                   if (!identical(...future.globals.maxSize.org, 
[15:32:44.899]                     ...future.globals.maxSize)) {
[15:32:44.899]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.899]                     on.exit(options(oopts), add = TRUE)
[15:32:44.899]                   }
[15:32:44.899]                   {
[15:32:44.899]                     lapply(seq_along(...future.elements_ii), 
[15:32:44.899]                       FUN = function(jj) {
[15:32:44.899]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.899]                         ...future.FUN(...future.X_jj, ...)
[15:32:44.899]                       })
[15:32:44.899]                   }
[15:32:44.899]                 }, args = future.call.arguments)
[15:32:44.899]             }))
[15:32:44.899]             future::FutureResult(value = ...future.value$value, 
[15:32:44.899]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:44.899]                   ...future.rng), globalenv = if (FALSE) 
[15:32:44.899]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:44.899]                     ...future.globalenv.names))
[15:32:44.899]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:44.899]         }, condition = base::local({
[15:32:44.899]             c <- base::c
[15:32:44.899]             inherits <- base::inherits
[15:32:44.899]             invokeRestart <- base::invokeRestart
[15:32:44.899]             length <- base::length
[15:32:44.899]             list <- base::list
[15:32:44.899]             seq.int <- base::seq.int
[15:32:44.899]             signalCondition <- base::signalCondition
[15:32:44.899]             sys.calls <- base::sys.calls
[15:32:44.899]             `[[` <- base::`[[`
[15:32:44.899]             `+` <- base::`+`
[15:32:44.899]             `<<-` <- base::`<<-`
[15:32:44.899]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:44.899]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:44.899]                   3L)]
[15:32:44.899]             }
[15:32:44.899]             function(cond) {
[15:32:44.899]                 is_error <- inherits(cond, "error")
[15:32:44.899]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:44.899]                   NULL)
[15:32:44.899]                 if (is_error) {
[15:32:44.899]                   sessionInformation <- function() {
[15:32:44.899]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:44.899]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:44.899]                       search = base::search(), system = base::Sys.info())
[15:32:44.899]                   }
[15:32:44.899]                   ...future.conditions[[length(...future.conditions) + 
[15:32:44.899]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:44.899]                     cond$call), session = sessionInformation(), 
[15:32:44.899]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:44.899]                   signalCondition(cond)
[15:32:44.899]                 }
[15:32:44.899]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:44.899]                 "immediateCondition"))) {
[15:32:44.899]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:44.899]                   ...future.conditions[[length(...future.conditions) + 
[15:32:44.899]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:44.899]                   if (TRUE && !signal) {
[15:32:44.899]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:44.899]                     {
[15:32:44.899]                       inherits <- base::inherits
[15:32:44.899]                       invokeRestart <- base::invokeRestart
[15:32:44.899]                       is.null <- base::is.null
[15:32:44.899]                       muffled <- FALSE
[15:32:44.899]                       if (inherits(cond, "message")) {
[15:32:44.899]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:44.899]                         if (muffled) 
[15:32:44.899]                           invokeRestart("muffleMessage")
[15:32:44.899]                       }
[15:32:44.899]                       else if (inherits(cond, "warning")) {
[15:32:44.899]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:44.899]                         if (muffled) 
[15:32:44.899]                           invokeRestart("muffleWarning")
[15:32:44.899]                       }
[15:32:44.899]                       else if (inherits(cond, "condition")) {
[15:32:44.899]                         if (!is.null(pattern)) {
[15:32:44.899]                           computeRestarts <- base::computeRestarts
[15:32:44.899]                           grepl <- base::grepl
[15:32:44.899]                           restarts <- computeRestarts(cond)
[15:32:44.899]                           for (restart in restarts) {
[15:32:44.899]                             name <- restart$name
[15:32:44.899]                             if (is.null(name)) 
[15:32:44.899]                               next
[15:32:44.899]                             if (!grepl(pattern, name)) 
[15:32:44.899]                               next
[15:32:44.899]                             invokeRestart(restart)
[15:32:44.899]                             muffled <- TRUE
[15:32:44.899]                             break
[15:32:44.899]                           }
[15:32:44.899]                         }
[15:32:44.899]                       }
[15:32:44.899]                       invisible(muffled)
[15:32:44.899]                     }
[15:32:44.899]                     muffleCondition(cond, pattern = "^muffle")
[15:32:44.899]                   }
[15:32:44.899]                 }
[15:32:44.899]                 else {
[15:32:44.899]                   if (TRUE) {
[15:32:44.899]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:44.899]                     {
[15:32:44.899]                       inherits <- base::inherits
[15:32:44.899]                       invokeRestart <- base::invokeRestart
[15:32:44.899]                       is.null <- base::is.null
[15:32:44.899]                       muffled <- FALSE
[15:32:44.899]                       if (inherits(cond, "message")) {
[15:32:44.899]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:44.899]                         if (muffled) 
[15:32:44.899]                           invokeRestart("muffleMessage")
[15:32:44.899]                       }
[15:32:44.899]                       else if (inherits(cond, "warning")) {
[15:32:44.899]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:44.899]                         if (muffled) 
[15:32:44.899]                           invokeRestart("muffleWarning")
[15:32:44.899]                       }
[15:32:44.899]                       else if (inherits(cond, "condition")) {
[15:32:44.899]                         if (!is.null(pattern)) {
[15:32:44.899]                           computeRestarts <- base::computeRestarts
[15:32:44.899]                           grepl <- base::grepl
[15:32:44.899]                           restarts <- computeRestarts(cond)
[15:32:44.899]                           for (restart in restarts) {
[15:32:44.899]                             name <- restart$name
[15:32:44.899]                             if (is.null(name)) 
[15:32:44.899]                               next
[15:32:44.899]                             if (!grepl(pattern, name)) 
[15:32:44.899]                               next
[15:32:44.899]                             invokeRestart(restart)
[15:32:44.899]                             muffled <- TRUE
[15:32:44.899]                             break
[15:32:44.899]                           }
[15:32:44.899]                         }
[15:32:44.899]                       }
[15:32:44.899]                       invisible(muffled)
[15:32:44.899]                     }
[15:32:44.899]                     muffleCondition(cond, pattern = "^muffle")
[15:32:44.899]                   }
[15:32:44.899]                 }
[15:32:44.899]             }
[15:32:44.899]         }))
[15:32:44.899]     }, error = function(ex) {
[15:32:44.899]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:44.899]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:44.899]                 ...future.rng), started = ...future.startTime, 
[15:32:44.899]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:44.899]             version = "1.8"), class = "FutureResult")
[15:32:44.899]     }, finally = {
[15:32:44.899]         if (!identical(...future.workdir, getwd())) 
[15:32:44.899]             setwd(...future.workdir)
[15:32:44.899]         {
[15:32:44.899]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:44.899]                 ...future.oldOptions$nwarnings <- NULL
[15:32:44.899]             }
[15:32:44.899]             base::options(...future.oldOptions)
[15:32:44.899]             if (.Platform$OS.type == "windows") {
[15:32:44.899]                 old_names <- names(...future.oldEnvVars)
[15:32:44.899]                 envs <- base::Sys.getenv()
[15:32:44.899]                 names <- names(envs)
[15:32:44.899]                 common <- intersect(names, old_names)
[15:32:44.899]                 added <- setdiff(names, old_names)
[15:32:44.899]                 removed <- setdiff(old_names, names)
[15:32:44.899]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:44.899]                   envs[common]]
[15:32:44.899]                 NAMES <- toupper(changed)
[15:32:44.899]                 args <- list()
[15:32:44.899]                 for (kk in seq_along(NAMES)) {
[15:32:44.899]                   name <- changed[[kk]]
[15:32:44.899]                   NAME <- NAMES[[kk]]
[15:32:44.899]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.899]                     next
[15:32:44.899]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:44.899]                 }
[15:32:44.899]                 NAMES <- toupper(added)
[15:32:44.899]                 for (kk in seq_along(NAMES)) {
[15:32:44.899]                   name <- added[[kk]]
[15:32:44.899]                   NAME <- NAMES[[kk]]
[15:32:44.899]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.899]                     next
[15:32:44.899]                   args[[name]] <- ""
[15:32:44.899]                 }
[15:32:44.899]                 NAMES <- toupper(removed)
[15:32:44.899]                 for (kk in seq_along(NAMES)) {
[15:32:44.899]                   name <- removed[[kk]]
[15:32:44.899]                   NAME <- NAMES[[kk]]
[15:32:44.899]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:44.899]                     next
[15:32:44.899]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:44.899]                 }
[15:32:44.899]                 if (length(args) > 0) 
[15:32:44.899]                   base::do.call(base::Sys.setenv, args = args)
[15:32:44.899]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:44.899]             }
[15:32:44.899]             else {
[15:32:44.899]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:44.899]             }
[15:32:44.899]             {
[15:32:44.899]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:44.899]                   0L) {
[15:32:44.899]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:44.899]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:44.899]                   base::options(opts)
[15:32:44.899]                 }
[15:32:44.899]                 {
[15:32:44.899]                   {
[15:32:44.899]                     NULL
[15:32:44.899]                     RNGkind("Mersenne-Twister")
[15:32:44.899]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:44.899]                       inherits = FALSE)
[15:32:44.899]                   }
[15:32:44.899]                   options(future.plan = NULL)
[15:32:44.899]                   if (is.na(NA_character_)) 
[15:32:44.899]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:44.899]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:44.899]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:44.899]                     .init = FALSE)
[15:32:44.899]                 }
[15:32:44.899]             }
[15:32:44.899]         }
[15:32:44.899]     })
[15:32:44.899]     if (TRUE) {
[15:32:44.899]         base::sink(type = "output", split = FALSE)
[15:32:44.899]         if (TRUE) {
[15:32:44.899]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:44.899]         }
[15:32:44.899]         else {
[15:32:44.899]             ...future.result["stdout"] <- base::list(NULL)
[15:32:44.899]         }
[15:32:44.899]         base::close(...future.stdout)
[15:32:44.899]         ...future.stdout <- NULL
[15:32:44.899]     }
[15:32:44.899]     ...future.result$conditions <- ...future.conditions
[15:32:44.899]     ...future.result$finished <- base::Sys.time()
[15:32:44.899]     ...future.result
[15:32:44.899] }
[15:32:44.906] assign_globals() ...
[15:32:44.906] List of 11
[15:32:44.906]  $ ...future.FUN            :function (x, ...)  
[15:32:44.906]  $ x_FUN                    :function (x)  
[15:32:44.906]  $ times                    : int 4
[15:32:44.906]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.906]  $ stop_if_not              :function (...)  
[15:32:44.906]  $ dim                      : int [1:2] 2 2
[15:32:44.906]  $ valid_types              : chr [1:2] "logical" "integer"
[15:32:44.906]  $ future.call.arguments    : list()
[15:32:44.906]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.906]  $ ...future.elements_ii    :List of 10
[15:32:44.906]   ..$ : int 1
[15:32:44.906]   ..$ : int 2
[15:32:44.906]   ..$ : int 3
[15:32:44.906]   ..$ : int 4
[15:32:44.906]   ..$ : int 5
[15:32:44.906]   ..$ : int 6
[15:32:44.906]   ..$ : int 7
[15:32:44.906]   ..$ : int 8
[15:32:44.906]   ..$ : int 9
[15:32:44.906]   ..$ : int 10
[15:32:44.906]  $ ...future.seeds_ii       : NULL
[15:32:44.906]  $ ...future.globals.maxSize: NULL
[15:32:44.906]  - attr(*, "where")=List of 11
[15:32:44.906]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:44.906]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:44.906]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:44.906]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:44.906]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:44.906]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:44.906]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:44.906]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:44.906]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:44.906]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:44.906]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:44.906]  - attr(*, "resolved")= logi FALSE
[15:32:44.906]  - attr(*, "total_size")= num 97232
[15:32:44.906]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.906]  - attr(*, "already-done")= logi TRUE
[15:32:44.930] - copied '...future.FUN' to environment
[15:32:44.931] - reassign environment for 'x_FUN'
[15:32:44.931] - copied 'x_FUN' to environment
[15:32:44.931] - copied 'times' to environment
[15:32:44.932] - copied 'stopf' to environment
[15:32:44.932] - copied 'stop_if_not' to environment
[15:32:44.932] - copied 'dim' to environment
[15:32:44.933] - copied 'valid_types' to environment
[15:32:44.933] - copied 'future.call.arguments' to environment
[15:32:44.933] - copied '...future.elements_ii' to environment
[15:32:44.933] - copied '...future.seeds_ii' to environment
[15:32:44.934] - copied '...future.globals.maxSize' to environment
[15:32:44.934] assign_globals() ... done
[15:32:44.935] plan(): Setting new future strategy stack:
[15:32:44.935] List of future strategies:
[15:32:44.935] 1. sequential:
[15:32:44.935]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.935]    - tweaked: FALSE
[15:32:44.935]    - call: NULL
[15:32:44.936] plan(): nbrOfWorkers() = 1
[15:32:44.938] plan(): Setting new future strategy stack:
[15:32:44.939] List of future strategies:
[15:32:44.939] 1. sequential:
[15:32:44.939]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:44.939]    - tweaked: FALSE
[15:32:44.939]    - call: plan(strategy)
[15:32:44.940] plan(): nbrOfWorkers() = 1
[15:32:44.940] SequentialFuture started (and completed)
[15:32:44.941] - Launch lazy future ... done
[15:32:44.941] run() for 'SequentialFuture' ... done
[15:32:44.941] Created future:
[15:32:44.942] SequentialFuture:
[15:32:44.942] Label: 'future_vapply-1'
[15:32:44.942] Expression:
[15:32:44.942] {
[15:32:44.942]     do.call(function(...) {
[15:32:44.942]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:44.942]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:44.942]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:44.942]             on.exit(options(oopts), add = TRUE)
[15:32:44.942]         }
[15:32:44.942]         {
[15:32:44.942]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:44.942]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:44.942]                 ...future.FUN(...future.X_jj, ...)
[15:32:44.942]             })
[15:32:44.942]         }
[15:32:44.942]     }, args = future.call.arguments)
[15:32:44.942] }
[15:32:44.942] Lazy evaluation: FALSE
[15:32:44.942] Asynchronous evaluation: FALSE
[15:32:44.942] Local evaluation: TRUE
[15:32:44.942] Environment: R_GlobalEnv
[15:32:44.942] Capture standard output: TRUE
[15:32:44.942] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:44.942] Globals: 11 objects totaling 95.50 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 2.90 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:44.942] Packages: 1 packages ('future.apply')
[15:32:44.942] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:44.942] Resolved: TRUE
[15:32:44.942] Value: 2.27 KiB of class 'list'
[15:32:44.942] Early signaling: FALSE
[15:32:44.942] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:44.942] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:44.944] Chunk #1 of 1 ... DONE
[15:32:44.945] Launching 1 futures (chunks) ... DONE
[15:32:44.945] Resolving 1 futures (chunks) ...
[15:32:44.945] resolve() on list ...
[15:32:44.945]  recursive: 0
[15:32:44.946]  length: 1
[15:32:44.946] 
[15:32:44.946] resolved() for 'SequentialFuture' ...
[15:32:44.947] - state: 'finished'
[15:32:44.947] - run: TRUE
[15:32:44.947] - result: 'FutureResult'
[15:32:44.947] resolved() for 'SequentialFuture' ... done
[15:32:44.948] Future #1
[15:32:44.948] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:44.949] - nx: 1
[15:32:44.949] - relay: TRUE
[15:32:44.949] - stdout: TRUE
[15:32:44.949] - signal: TRUE
[15:32:44.950] - resignal: FALSE
[15:32:44.950] - force: TRUE
[15:32:44.950] - relayed: [n=1] FALSE
[15:32:44.950] - queued futures: [n=1] FALSE
[15:32:44.951]  - until=1
[15:32:44.953]  - relaying element #1
[15:32:44.954] - relayed: [n=1] TRUE
[15:32:44.954] - queued futures: [n=1] TRUE
[15:32:44.955] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:44.955]  length: 0 (resolved future 1)
[15:32:44.955] Relaying remaining futures
[15:32:44.956] signalConditionsASAP(NULL, pos=0) ...
[15:32:44.956] - nx: 1
[15:32:44.956] - relay: TRUE
[15:32:44.957] - stdout: TRUE
[15:32:44.957] - signal: TRUE
[15:32:44.957] - resignal: FALSE
[15:32:44.958] - force: TRUE
[15:32:44.958] - relayed: [n=1] TRUE
[15:32:44.958] - queued futures: [n=1] TRUE
 - flush all
[15:32:44.959] - relayed: [n=1] TRUE
[15:32:44.959] - queued futures: [n=1] TRUE
[15:32:44.959] signalConditionsASAP(NULL, pos=0) ... done
[15:32:44.960] resolve() on list ... DONE
[15:32:44.960]  - Number of value chunks collected: 1
[15:32:44.960] Resolving 1 futures (chunks) ... DONE
[15:32:44.961] Reducing values from 1 chunks ...
[15:32:44.961]  - Number of values collected after concatenation: 10
[15:32:44.961]  - Number of values expected: 10
[15:32:44.961] Reducing values from 1 chunks ... DONE
[15:32:44.962] future_lapply() ... DONE
 int [1:2, 1:2, 1:10] 1 1 1 1 2 2 2 2 3 3 ...
 num [1:2, 1:2, 1:10] 1 1 1 1 2 2 2 2 3 3 ...
[15:32:44.964] future_lapply() ...
[15:32:44.968] Number of chunks: 1
[15:32:44.968] getGlobalsAndPackagesXApply() ...
[15:32:44.968]  - future.globals: TRUE
[15:32:44.969] getGlobalsAndPackages() ...
[15:32:44.969] Searching for globals...
[15:32:44.977] - globals found: [17] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'matrix'
[15:32:44.977] Searching for globals ... DONE
[15:32:44.977] Resolving globals: FALSE
[15:32:44.979] The total size of the 7 globals is 95.02 KiB (97304 bytes)
[15:32:44.980] The total size of the 7 globals exported for future expression ('FUN()') is 95.02 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:44.981] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.981] - packages: [1] 'future.apply'
[15:32:44.981] getGlobalsAndPackages() ... DONE
[15:32:44.982]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:44.982]  - needed namespaces: [n=1] 'future.apply'
[15:32:44.982] Finding globals ... DONE
[15:32:44.982]  - use_args: TRUE
[15:32:44.983]  - Getting '...' globals ...
[15:32:44.983] resolve() on list ...
[15:32:44.984]  recursive: 0
[15:32:44.984]  length: 1
[15:32:44.984]  elements: '...'
[15:32:44.985]  length: 0 (resolved future 1)
[15:32:44.985] resolve() on list ... DONE
[15:32:44.985]    - '...' content: [n=0] 
[15:32:44.985] List of 1
[15:32:44.985]  $ ...: list()
[15:32:44.985]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.985]  - attr(*, "where")=List of 1
[15:32:44.985]   ..$ ...:<environment: 0x0000022d3c28ec70> 
[15:32:44.985]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.985]  - attr(*, "resolved")= logi TRUE
[15:32:44.985]  - attr(*, "total_size")= num NA
[15:32:44.990]  - Getting '...' globals ... DONE
[15:32:44.991] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:44.991] List of 8
[15:32:44.991]  $ ...future.FUN:function (x, ...)  
[15:32:44.991]  $ x_FUN        :function (x)  
[15:32:44.991]  $ times        : int 4
[15:32:44.991]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:44.991]  $ stop_if_not  :function (...)  
[15:32:44.991]  $ dim          : int [1:2] 2 2
[15:32:44.991]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:44.991]  $ ...          : list()
[15:32:44.991]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:44.991]  - attr(*, "where")=List of 8
[15:32:44.991]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:44.991]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:44.991]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:44.991]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:44.991]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:44.991]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:44.991]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:44.991]   ..$ ...          :<environment: 0x0000022d3c28ec70> 
[15:32:44.991]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:44.991]  - attr(*, "resolved")= logi FALSE
[15:32:44.991]  - attr(*, "total_size")= num 97304
[15:32:45.005] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:45.005] getGlobalsAndPackagesXApply() ... DONE
[15:32:45.006] Number of futures (= number of chunks): 1
[15:32:45.006] Launching 1 futures (chunks) ...
[15:32:45.006] Chunk #1 of 1 ...
[15:32:45.006]  - Finding globals in 'X' for chunk #1 ...
[15:32:45.007] getGlobalsAndPackages() ...
[15:32:45.007] Searching for globals...
[15:32:45.008] 
[15:32:45.008] Searching for globals ... DONE
[15:32:45.008] - globals: [0] <none>
[15:32:45.009] getGlobalsAndPackages() ... DONE
[15:32:45.009]    + additional globals found: [n=0] 
[15:32:45.009]    + additional namespaces needed: [n=0] 
[15:32:45.009]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:45.010]  - seeds: <none>
[15:32:45.010]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.010] getGlobalsAndPackages() ...
[15:32:45.011] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.011] Resolving globals: FALSE
[15:32:45.011] Tweak future expression to call with '...' arguments ...
[15:32:45.012] {
[15:32:45.012]     do.call(function(...) {
[15:32:45.012]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.012]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.012]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.012]             on.exit(options(oopts), add = TRUE)
[15:32:45.012]         }
[15:32:45.012]         {
[15:32:45.012]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.012]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.012]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.012]             })
[15:32:45.012]         }
[15:32:45.012]     }, args = future.call.arguments)
[15:32:45.012] }
[15:32:45.012] Tweak future expression to call with '...' arguments ... DONE
[15:32:45.014] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.014] - packages: [1] 'future.apply'
[15:32:45.014] getGlobalsAndPackages() ... DONE
[15:32:45.015] run() for 'Future' ...
[15:32:45.015] - state: 'created'
[15:32:45.016] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:45.016] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.017] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:45.017]   - Field: 'label'
[15:32:45.017]   - Field: 'local'
[15:32:45.018]   - Field: 'owner'
[15:32:45.018]   - Field: 'envir'
[15:32:45.018]   - Field: 'packages'
[15:32:45.019]   - Field: 'gc'
[15:32:45.019]   - Field: 'conditions'
[15:32:45.019]   - Field: 'expr'
[15:32:45.020]   - Field: 'uuid'
[15:32:45.020]   - Field: 'seed'
[15:32:45.020]   - Field: 'version'
[15:32:45.021]   - Field: 'result'
[15:32:45.021]   - Field: 'asynchronous'
[15:32:45.021]   - Field: 'calls'
[15:32:45.022]   - Field: 'globals'
[15:32:45.022]   - Field: 'stdout'
[15:32:45.022]   - Field: 'earlySignal'
[15:32:45.023]   - Field: 'lazy'
[15:32:45.023]   - Field: 'state'
[15:32:45.023] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:45.024] - Launch lazy future ...
[15:32:45.024] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:45.024] Packages needed by future strategies (n = 0): <none>
[15:32:45.026] {
[15:32:45.026]     {
[15:32:45.026]         {
[15:32:45.026]             ...future.startTime <- base::Sys.time()
[15:32:45.026]             {
[15:32:45.026]                 {
[15:32:45.026]                   {
[15:32:45.026]                     {
[15:32:45.026]                       base::local({
[15:32:45.026]                         has_future <- base::requireNamespace("future", 
[15:32:45.026]                           quietly = TRUE)
[15:32:45.026]                         if (has_future) {
[15:32:45.026]                           ns <- base::getNamespace("future")
[15:32:45.026]                           version <- ns[[".package"]][["version"]]
[15:32:45.026]                           if (is.null(version)) 
[15:32:45.026]                             version <- utils::packageVersion("future")
[15:32:45.026]                         }
[15:32:45.026]                         else {
[15:32:45.026]                           version <- NULL
[15:32:45.026]                         }
[15:32:45.026]                         if (!has_future || version < "1.8.0") {
[15:32:45.026]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:45.026]                             "", base::R.version$version.string), 
[15:32:45.026]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:45.026]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:45.026]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:45.026]                               "release", "version")], collapse = " "), 
[15:32:45.026]                             hostname = base::Sys.info()[["nodename"]])
[15:32:45.026]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:45.026]                             info)
[15:32:45.026]                           info <- base::paste(info, collapse = "; ")
[15:32:45.026]                           if (!has_future) {
[15:32:45.026]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:45.026]                               info)
[15:32:45.026]                           }
[15:32:45.026]                           else {
[15:32:45.026]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:45.026]                               info, version)
[15:32:45.026]                           }
[15:32:45.026]                           base::stop(msg)
[15:32:45.026]                         }
[15:32:45.026]                       })
[15:32:45.026]                     }
[15:32:45.026]                     base::local({
[15:32:45.026]                       for (pkg in "future.apply") {
[15:32:45.026]                         base::loadNamespace(pkg)
[15:32:45.026]                         base::library(pkg, character.only = TRUE)
[15:32:45.026]                       }
[15:32:45.026]                     })
[15:32:45.026]                   }
[15:32:45.026]                   ...future.strategy.old <- future::plan("list")
[15:32:45.026]                   options(future.plan = NULL)
[15:32:45.026]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.026]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:45.026]                 }
[15:32:45.026]                 ...future.workdir <- getwd()
[15:32:45.026]             }
[15:32:45.026]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:45.026]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:45.026]         }
[15:32:45.026]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:45.026]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:45.026]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:45.026]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:45.026]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:45.026]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:45.026]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:45.026]             base::names(...future.oldOptions))
[15:32:45.026]     }
[15:32:45.026]     if (FALSE) {
[15:32:45.026]     }
[15:32:45.026]     else {
[15:32:45.026]         if (TRUE) {
[15:32:45.026]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:45.026]                 open = "w")
[15:32:45.026]         }
[15:32:45.026]         else {
[15:32:45.026]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:45.026]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:45.026]         }
[15:32:45.026]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:45.026]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:45.026]             base::sink(type = "output", split = FALSE)
[15:32:45.026]             base::close(...future.stdout)
[15:32:45.026]         }, add = TRUE)
[15:32:45.026]     }
[15:32:45.026]     ...future.frame <- base::sys.nframe()
[15:32:45.026]     ...future.conditions <- base::list()
[15:32:45.026]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:45.026]     if (FALSE) {
[15:32:45.026]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:45.026]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:45.026]     }
[15:32:45.026]     ...future.result <- base::tryCatch({
[15:32:45.026]         base::withCallingHandlers({
[15:32:45.026]             ...future.value <- base::withVisible(base::local({
[15:32:45.026]                 do.call(function(...) {
[15:32:45.026]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.026]                   if (!identical(...future.globals.maxSize.org, 
[15:32:45.026]                     ...future.globals.maxSize)) {
[15:32:45.026]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.026]                     on.exit(options(oopts), add = TRUE)
[15:32:45.026]                   }
[15:32:45.026]                   {
[15:32:45.026]                     lapply(seq_along(...future.elements_ii), 
[15:32:45.026]                       FUN = function(jj) {
[15:32:45.026]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.026]                         ...future.FUN(...future.X_jj, ...)
[15:32:45.026]                       })
[15:32:45.026]                   }
[15:32:45.026]                 }, args = future.call.arguments)
[15:32:45.026]             }))
[15:32:45.026]             future::FutureResult(value = ...future.value$value, 
[15:32:45.026]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.026]                   ...future.rng), globalenv = if (FALSE) 
[15:32:45.026]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:45.026]                     ...future.globalenv.names))
[15:32:45.026]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:45.026]         }, condition = base::local({
[15:32:45.026]             c <- base::c
[15:32:45.026]             inherits <- base::inherits
[15:32:45.026]             invokeRestart <- base::invokeRestart
[15:32:45.026]             length <- base::length
[15:32:45.026]             list <- base::list
[15:32:45.026]             seq.int <- base::seq.int
[15:32:45.026]             signalCondition <- base::signalCondition
[15:32:45.026]             sys.calls <- base::sys.calls
[15:32:45.026]             `[[` <- base::`[[`
[15:32:45.026]             `+` <- base::`+`
[15:32:45.026]             `<<-` <- base::`<<-`
[15:32:45.026]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:45.026]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:45.026]                   3L)]
[15:32:45.026]             }
[15:32:45.026]             function(cond) {
[15:32:45.026]                 is_error <- inherits(cond, "error")
[15:32:45.026]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:45.026]                   NULL)
[15:32:45.026]                 if (is_error) {
[15:32:45.026]                   sessionInformation <- function() {
[15:32:45.026]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:45.026]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:45.026]                       search = base::search(), system = base::Sys.info())
[15:32:45.026]                   }
[15:32:45.026]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.026]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:45.026]                     cond$call), session = sessionInformation(), 
[15:32:45.026]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:45.026]                   signalCondition(cond)
[15:32:45.026]                 }
[15:32:45.026]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:45.026]                 "immediateCondition"))) {
[15:32:45.026]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:45.026]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.026]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:45.026]                   if (TRUE && !signal) {
[15:32:45.026]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.026]                     {
[15:32:45.026]                       inherits <- base::inherits
[15:32:45.026]                       invokeRestart <- base::invokeRestart
[15:32:45.026]                       is.null <- base::is.null
[15:32:45.026]                       muffled <- FALSE
[15:32:45.026]                       if (inherits(cond, "message")) {
[15:32:45.026]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.026]                         if (muffled) 
[15:32:45.026]                           invokeRestart("muffleMessage")
[15:32:45.026]                       }
[15:32:45.026]                       else if (inherits(cond, "warning")) {
[15:32:45.026]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.026]                         if (muffled) 
[15:32:45.026]                           invokeRestart("muffleWarning")
[15:32:45.026]                       }
[15:32:45.026]                       else if (inherits(cond, "condition")) {
[15:32:45.026]                         if (!is.null(pattern)) {
[15:32:45.026]                           computeRestarts <- base::computeRestarts
[15:32:45.026]                           grepl <- base::grepl
[15:32:45.026]                           restarts <- computeRestarts(cond)
[15:32:45.026]                           for (restart in restarts) {
[15:32:45.026]                             name <- restart$name
[15:32:45.026]                             if (is.null(name)) 
[15:32:45.026]                               next
[15:32:45.026]                             if (!grepl(pattern, name)) 
[15:32:45.026]                               next
[15:32:45.026]                             invokeRestart(restart)
[15:32:45.026]                             muffled <- TRUE
[15:32:45.026]                             break
[15:32:45.026]                           }
[15:32:45.026]                         }
[15:32:45.026]                       }
[15:32:45.026]                       invisible(muffled)
[15:32:45.026]                     }
[15:32:45.026]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.026]                   }
[15:32:45.026]                 }
[15:32:45.026]                 else {
[15:32:45.026]                   if (TRUE) {
[15:32:45.026]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.026]                     {
[15:32:45.026]                       inherits <- base::inherits
[15:32:45.026]                       invokeRestart <- base::invokeRestart
[15:32:45.026]                       is.null <- base::is.null
[15:32:45.026]                       muffled <- FALSE
[15:32:45.026]                       if (inherits(cond, "message")) {
[15:32:45.026]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.026]                         if (muffled) 
[15:32:45.026]                           invokeRestart("muffleMessage")
[15:32:45.026]                       }
[15:32:45.026]                       else if (inherits(cond, "warning")) {
[15:32:45.026]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.026]                         if (muffled) 
[15:32:45.026]                           invokeRestart("muffleWarning")
[15:32:45.026]                       }
[15:32:45.026]                       else if (inherits(cond, "condition")) {
[15:32:45.026]                         if (!is.null(pattern)) {
[15:32:45.026]                           computeRestarts <- base::computeRestarts
[15:32:45.026]                           grepl <- base::grepl
[15:32:45.026]                           restarts <- computeRestarts(cond)
[15:32:45.026]                           for (restart in restarts) {
[15:32:45.026]                             name <- restart$name
[15:32:45.026]                             if (is.null(name)) 
[15:32:45.026]                               next
[15:32:45.026]                             if (!grepl(pattern, name)) 
[15:32:45.026]                               next
[15:32:45.026]                             invokeRestart(restart)
[15:32:45.026]                             muffled <- TRUE
[15:32:45.026]                             break
[15:32:45.026]                           }
[15:32:45.026]                         }
[15:32:45.026]                       }
[15:32:45.026]                       invisible(muffled)
[15:32:45.026]                     }
[15:32:45.026]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.026]                   }
[15:32:45.026]                 }
[15:32:45.026]             }
[15:32:45.026]         }))
[15:32:45.026]     }, error = function(ex) {
[15:32:45.026]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:45.026]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.026]                 ...future.rng), started = ...future.startTime, 
[15:32:45.026]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:45.026]             version = "1.8"), class = "FutureResult")
[15:32:45.026]     }, finally = {
[15:32:45.026]         if (!identical(...future.workdir, getwd())) 
[15:32:45.026]             setwd(...future.workdir)
[15:32:45.026]         {
[15:32:45.026]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:45.026]                 ...future.oldOptions$nwarnings <- NULL
[15:32:45.026]             }
[15:32:45.026]             base::options(...future.oldOptions)
[15:32:45.026]             if (.Platform$OS.type == "windows") {
[15:32:45.026]                 old_names <- names(...future.oldEnvVars)
[15:32:45.026]                 envs <- base::Sys.getenv()
[15:32:45.026]                 names <- names(envs)
[15:32:45.026]                 common <- intersect(names, old_names)
[15:32:45.026]                 added <- setdiff(names, old_names)
[15:32:45.026]                 removed <- setdiff(old_names, names)
[15:32:45.026]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:45.026]                   envs[common]]
[15:32:45.026]                 NAMES <- toupper(changed)
[15:32:45.026]                 args <- list()
[15:32:45.026]                 for (kk in seq_along(NAMES)) {
[15:32:45.026]                   name <- changed[[kk]]
[15:32:45.026]                   NAME <- NAMES[[kk]]
[15:32:45.026]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.026]                     next
[15:32:45.026]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.026]                 }
[15:32:45.026]                 NAMES <- toupper(added)
[15:32:45.026]                 for (kk in seq_along(NAMES)) {
[15:32:45.026]                   name <- added[[kk]]
[15:32:45.026]                   NAME <- NAMES[[kk]]
[15:32:45.026]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.026]                     next
[15:32:45.026]                   args[[name]] <- ""
[15:32:45.026]                 }
[15:32:45.026]                 NAMES <- toupper(removed)
[15:32:45.026]                 for (kk in seq_along(NAMES)) {
[15:32:45.026]                   name <- removed[[kk]]
[15:32:45.026]                   NAME <- NAMES[[kk]]
[15:32:45.026]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.026]                     next
[15:32:45.026]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.026]                 }
[15:32:45.026]                 if (length(args) > 0) 
[15:32:45.026]                   base::do.call(base::Sys.setenv, args = args)
[15:32:45.026]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:45.026]             }
[15:32:45.026]             else {
[15:32:45.026]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:45.026]             }
[15:32:45.026]             {
[15:32:45.026]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:45.026]                   0L) {
[15:32:45.026]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:45.026]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:45.026]                   base::options(opts)
[15:32:45.026]                 }
[15:32:45.026]                 {
[15:32:45.026]                   {
[15:32:45.026]                     NULL
[15:32:45.026]                     RNGkind("Mersenne-Twister")
[15:32:45.026]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:45.026]                       inherits = FALSE)
[15:32:45.026]                   }
[15:32:45.026]                   options(future.plan = NULL)
[15:32:45.026]                   if (is.na(NA_character_)) 
[15:32:45.026]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.026]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:45.026]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:45.026]                     .init = FALSE)
[15:32:45.026]                 }
[15:32:45.026]             }
[15:32:45.026]         }
[15:32:45.026]     })
[15:32:45.026]     if (TRUE) {
[15:32:45.026]         base::sink(type = "output", split = FALSE)
[15:32:45.026]         if (TRUE) {
[15:32:45.026]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:45.026]         }
[15:32:45.026]         else {
[15:32:45.026]             ...future.result["stdout"] <- base::list(NULL)
[15:32:45.026]         }
[15:32:45.026]         base::close(...future.stdout)
[15:32:45.026]         ...future.stdout <- NULL
[15:32:45.026]     }
[15:32:45.026]     ...future.result$conditions <- ...future.conditions
[15:32:45.026]     ...future.result$finished <- base::Sys.time()
[15:32:45.026]     ...future.result
[15:32:45.026] }
[15:32:45.033] assign_globals() ...
[15:32:45.033] List of 11
[15:32:45.033]  $ ...future.FUN            :function (x, ...)  
[15:32:45.033]  $ x_FUN                    :function (x)  
[15:32:45.033]  $ times                    : int 4
[15:32:45.033]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.033]  $ stop_if_not              :function (...)  
[15:32:45.033]  $ dim                      : int [1:2] 2 2
[15:32:45.033]  $ valid_types              : chr [1:3] "logical" "integer" "double"
[15:32:45.033]  $ future.call.arguments    : list()
[15:32:45.033]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.033]  $ ...future.elements_ii    :List of 10
[15:32:45.033]   ..$ : int 1
[15:32:45.033]   ..$ : int 2
[15:32:45.033]   ..$ : int 3
[15:32:45.033]   ..$ : int 4
[15:32:45.033]   ..$ : int 5
[15:32:45.033]   ..$ : int 6
[15:32:45.033]   ..$ : int 7
[15:32:45.033]   ..$ : int 8
[15:32:45.033]   ..$ : int 9
[15:32:45.033]   ..$ : int 10
[15:32:45.033]  $ ...future.seeds_ii       : NULL
[15:32:45.033]  $ ...future.globals.maxSize: NULL
[15:32:45.033]  - attr(*, "where")=List of 11
[15:32:45.033]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:45.033]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:45.033]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:45.033]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:45.033]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:45.033]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:45.033]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:45.033]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:45.033]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:45.033]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:45.033]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:45.033]  - attr(*, "resolved")= logi FALSE
[15:32:45.033]  - attr(*, "total_size")= num 97304
[15:32:45.033]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.033]  - attr(*, "already-done")= logi TRUE
[15:32:45.057] - copied '...future.FUN' to environment
[15:32:45.057] - reassign environment for 'x_FUN'
[15:32:45.057] - copied 'x_FUN' to environment
[15:32:45.058] - copied 'times' to environment
[15:32:45.058] - copied 'stopf' to environment
[15:32:45.058] - copied 'stop_if_not' to environment
[15:32:45.059] - copied 'dim' to environment
[15:32:45.059] - copied 'valid_types' to environment
[15:32:45.059] - copied 'future.call.arguments' to environment
[15:32:45.059] - copied '...future.elements_ii' to environment
[15:32:45.060] - copied '...future.seeds_ii' to environment
[15:32:45.060] - copied '...future.globals.maxSize' to environment
[15:32:45.060] assign_globals() ... done
[15:32:45.061] plan(): Setting new future strategy stack:
[15:32:45.062] List of future strategies:
[15:32:45.062] 1. sequential:
[15:32:45.062]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.062]    - tweaked: FALSE
[15:32:45.062]    - call: NULL
[15:32:45.063] plan(): nbrOfWorkers() = 1
[15:32:45.065] plan(): Setting new future strategy stack:
[15:32:45.065] List of future strategies:
[15:32:45.065] 1. sequential:
[15:32:45.065]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.065]    - tweaked: FALSE
[15:32:45.065]    - call: plan(strategy)
[15:32:45.066] plan(): nbrOfWorkers() = 1
[15:32:45.067] SequentialFuture started (and completed)
[15:32:45.067] - Launch lazy future ... done
[15:32:45.067] run() for 'SequentialFuture' ... done
[15:32:45.068] Created future:
[15:32:45.068] SequentialFuture:
[15:32:45.068] Label: 'future_vapply-1'
[15:32:45.068] Expression:
[15:32:45.068] {
[15:32:45.068]     do.call(function(...) {
[15:32:45.068]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.068]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.068]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.068]             on.exit(options(oopts), add = TRUE)
[15:32:45.068]         }
[15:32:45.068]         {
[15:32:45.068]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.068]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.068]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.068]             })
[15:32:45.068]         }
[15:32:45.068]     }, args = future.call.arguments)
[15:32:45.068] }
[15:32:45.068] Lazy evaluation: FALSE
[15:32:45.068] Asynchronous evaluation: FALSE
[15:32:45.068] Local evaluation: TRUE
[15:32:45.068] Environment: R_GlobalEnv
[15:32:45.068] Capture standard output: TRUE
[15:32:45.068] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:45.068] Globals: 11 objects totaling 95.57 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 2.90 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:45.068] Packages: 1 packages ('future.apply')
[15:32:45.068] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:45.068] Resolved: TRUE
[15:32:45.068] Value: 2.27 KiB of class 'list'
[15:32:45.068] Early signaling: FALSE
[15:32:45.068] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:45.068] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.071] Chunk #1 of 1 ... DONE
[15:32:45.071] Launching 1 futures (chunks) ... DONE
[15:32:45.071] Resolving 1 futures (chunks) ...
[15:32:45.072] resolve() on list ...
[15:32:45.072]  recursive: 0
[15:32:45.072]  length: 1
[15:32:45.073] 
[15:32:45.073] resolved() for 'SequentialFuture' ...
[15:32:45.073] - state: 'finished'
[15:32:45.074] - run: TRUE
[15:32:45.074] - result: 'FutureResult'
[15:32:45.074] resolved() for 'SequentialFuture' ... done
[15:32:45.075] Future #1
[15:32:45.075] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:45.075] - nx: 1
[15:32:45.076] - relay: TRUE
[15:32:45.076] - stdout: TRUE
[15:32:45.076] - signal: TRUE
[15:32:45.076] - resignal: FALSE
[15:32:45.077] - force: TRUE
[15:32:45.077] - relayed: [n=1] FALSE
[15:32:45.077] - queued futures: [n=1] FALSE
[15:32:45.078]  - until=1
[15:32:45.078]  - relaying element #1
[15:32:45.078] - relayed: [n=1] TRUE
[15:32:45.079] - queued futures: [n=1] TRUE
[15:32:45.079] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:45.079]  length: 0 (resolved future 1)
[15:32:45.080] Relaying remaining futures
[15:32:45.080] signalConditionsASAP(NULL, pos=0) ...
[15:32:45.080] - nx: 1
[15:32:45.080] - relay: TRUE
[15:32:45.081] - stdout: TRUE
[15:32:45.081] - signal: TRUE
[15:32:45.081] - resignal: FALSE
[15:32:45.081] - force: TRUE
[15:32:45.082] - relayed: [n=1] TRUE
[15:32:45.082] - queued futures: [n=1] TRUE
 - flush all
[15:32:45.082] - relayed: [n=1] TRUE
[15:32:45.083] - queued futures: [n=1] TRUE
[15:32:45.083] signalConditionsASAP(NULL, pos=0) ... done
[15:32:45.083] resolve() on list ... DONE
[15:32:45.084]  - Number of value chunks collected: 1
[15:32:45.084] Resolving 1 futures (chunks) ... DONE
[15:32:45.084] Reducing values from 1 chunks ...
[15:32:45.085]  - Number of values collected after concatenation: 10
[15:32:45.085]  - Number of values expected: 10
[15:32:45.085] Reducing values from 1 chunks ... DONE
[15:32:45.085] future_lapply() ... DONE
 int [1:2, 1:2, 1:10] 1 1 1 1 2 2 2 2 3 3 ...
 num [1:2, 1:2, 1:10] 1 1 1 1 2 2 2 2 3 3 ...
 - attr(*, "dimnames")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:2] "A" "B"
  ..$ : NULL
[15:32:45.089] future_lapply() ...
[15:32:45.097] Number of chunks: 1
[15:32:45.097] getGlobalsAndPackagesXApply() ...
[15:32:45.098]  - future.globals: TRUE
[15:32:45.098] getGlobalsAndPackages() ...
[15:32:45.098] Searching for globals...
[15:32:45.106] - globals found: [19] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'matrix', 'list', 'c'
[15:32:45.107] Searching for globals ... DONE
[15:32:45.107] Resolving globals: FALSE
[15:32:45.109] The total size of the 7 globals is 103.08 KiB (105552 bytes)
[15:32:45.110] The total size of the 7 globals exported for future expression ('FUN()') is 103.08 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:45.110] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:45.111] - packages: [1] 'future.apply'
[15:32:45.111] getGlobalsAndPackages() ... DONE
[15:32:45.111]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:45.112]  - needed namespaces: [n=1] 'future.apply'
[15:32:45.112] Finding globals ... DONE
[15:32:45.112]  - use_args: TRUE
[15:32:45.112]  - Getting '...' globals ...
[15:32:45.113] resolve() on list ...
[15:32:45.114]  recursive: 0
[15:32:45.114]  length: 1
[15:32:45.114]  elements: '...'
[15:32:45.115]  length: 0 (resolved future 1)
[15:32:45.115] resolve() on list ... DONE
[15:32:45.115]    - '...' content: [n=0] 
[15:32:45.115] List of 1
[15:32:45.115]  $ ...: list()
[15:32:45.115]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.115]  - attr(*, "where")=List of 1
[15:32:45.115]   ..$ ...:<environment: 0x0000022d3e750d10> 
[15:32:45.115]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.115]  - attr(*, "resolved")= logi TRUE
[15:32:45.115]  - attr(*, "total_size")= num NA
[15:32:45.121]  - Getting '...' globals ... DONE
[15:32:45.121] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:45.121] List of 8
[15:32:45.121]  $ ...future.FUN:function (x, ...)  
[15:32:45.121]  $ x_FUN        :function (x)  
[15:32:45.121]  $ times        : int 4
[15:32:45.121]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.121]  $ stop_if_not  :function (...)  
[15:32:45.121]  $ dim          : int [1:2] 2 2
[15:32:45.121]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:45.121]  $ ...          : list()
[15:32:45.121]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.121]  - attr(*, "where")=List of 8
[15:32:45.121]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:45.121]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:45.121]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:45.121]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:45.121]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:45.121]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:45.121]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:45.121]   ..$ ...          :<environment: 0x0000022d3e750d10> 
[15:32:45.121]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.121]  - attr(*, "resolved")= logi FALSE
[15:32:45.121]  - attr(*, "total_size")= num 105552
[15:32:45.136] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:45.136] getGlobalsAndPackagesXApply() ... DONE
[15:32:45.137] Number of futures (= number of chunks): 1
[15:32:45.137] Launching 1 futures (chunks) ...
[15:32:45.138] Chunk #1 of 1 ...
[15:32:45.138]  - Finding globals in 'X' for chunk #1 ...
[15:32:45.138] getGlobalsAndPackages() ...
[15:32:45.138] Searching for globals...
[15:32:45.139] 
[15:32:45.139] Searching for globals ... DONE
[15:32:45.139] - globals: [0] <none>
[15:32:45.139] getGlobalsAndPackages() ... DONE
[15:32:45.140]    + additional globals found: [n=0] 
[15:32:45.140]    + additional namespaces needed: [n=0] 
[15:32:45.140]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:45.140]  - seeds: <none>
[15:32:45.140]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.141] getGlobalsAndPackages() ...
[15:32:45.141] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.141] Resolving globals: FALSE
[15:32:45.142] Tweak future expression to call with '...' arguments ...
[15:32:45.142] {
[15:32:45.142]     do.call(function(...) {
[15:32:45.142]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.142]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.142]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.142]             on.exit(options(oopts), add = TRUE)
[15:32:45.142]         }
[15:32:45.142]         {
[15:32:45.142]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.142]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.142]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.142]             })
[15:32:45.142]         }
[15:32:45.142]     }, args = future.call.arguments)
[15:32:45.142] }
[15:32:45.143] Tweak future expression to call with '...' arguments ... DONE
[15:32:45.144] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.144] - packages: [1] 'future.apply'
[15:32:45.145] getGlobalsAndPackages() ... DONE
[15:32:45.145] run() for 'Future' ...
[15:32:45.146] - state: 'created'
[15:32:45.146] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:45.147] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.147] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:45.147]   - Field: 'label'
[15:32:45.148]   - Field: 'local'
[15:32:45.148]   - Field: 'owner'
[15:32:45.148]   - Field: 'envir'
[15:32:45.149]   - Field: 'packages'
[15:32:45.149]   - Field: 'gc'
[15:32:45.149]   - Field: 'conditions'
[15:32:45.149]   - Field: 'expr'
[15:32:45.150]   - Field: 'uuid'
[15:32:45.150]   - Field: 'seed'
[15:32:45.150]   - Field: 'version'
[15:32:45.150]   - Field: 'result'
[15:32:45.151]   - Field: 'asynchronous'
[15:32:45.151]   - Field: 'calls'
[15:32:45.151]   - Field: 'globals'
[15:32:45.151]   - Field: 'stdout'
[15:32:45.152]   - Field: 'earlySignal'
[15:32:45.152]   - Field: 'lazy'
[15:32:45.152]   - Field: 'state'
[15:32:45.153] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:45.153] - Launch lazy future ...
[15:32:45.153] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:45.154] Packages needed by future strategies (n = 0): <none>
[15:32:45.155] {
[15:32:45.155]     {
[15:32:45.155]         {
[15:32:45.155]             ...future.startTime <- base::Sys.time()
[15:32:45.155]             {
[15:32:45.155]                 {
[15:32:45.155]                   {
[15:32:45.155]                     {
[15:32:45.155]                       base::local({
[15:32:45.155]                         has_future <- base::requireNamespace("future", 
[15:32:45.155]                           quietly = TRUE)
[15:32:45.155]                         if (has_future) {
[15:32:45.155]                           ns <- base::getNamespace("future")
[15:32:45.155]                           version <- ns[[".package"]][["version"]]
[15:32:45.155]                           if (is.null(version)) 
[15:32:45.155]                             version <- utils::packageVersion("future")
[15:32:45.155]                         }
[15:32:45.155]                         else {
[15:32:45.155]                           version <- NULL
[15:32:45.155]                         }
[15:32:45.155]                         if (!has_future || version < "1.8.0") {
[15:32:45.155]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:45.155]                             "", base::R.version$version.string), 
[15:32:45.155]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:45.155]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:45.155]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:45.155]                               "release", "version")], collapse = " "), 
[15:32:45.155]                             hostname = base::Sys.info()[["nodename"]])
[15:32:45.155]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:45.155]                             info)
[15:32:45.155]                           info <- base::paste(info, collapse = "; ")
[15:32:45.155]                           if (!has_future) {
[15:32:45.155]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:45.155]                               info)
[15:32:45.155]                           }
[15:32:45.155]                           else {
[15:32:45.155]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:45.155]                               info, version)
[15:32:45.155]                           }
[15:32:45.155]                           base::stop(msg)
[15:32:45.155]                         }
[15:32:45.155]                       })
[15:32:45.155]                     }
[15:32:45.155]                     base::local({
[15:32:45.155]                       for (pkg in "future.apply") {
[15:32:45.155]                         base::loadNamespace(pkg)
[15:32:45.155]                         base::library(pkg, character.only = TRUE)
[15:32:45.155]                       }
[15:32:45.155]                     })
[15:32:45.155]                   }
[15:32:45.155]                   ...future.strategy.old <- future::plan("list")
[15:32:45.155]                   options(future.plan = NULL)
[15:32:45.155]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.155]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:45.155]                 }
[15:32:45.155]                 ...future.workdir <- getwd()
[15:32:45.155]             }
[15:32:45.155]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:45.155]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:45.155]         }
[15:32:45.155]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:45.155]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:45.155]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:45.155]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:45.155]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:45.155]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:45.155]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:45.155]             base::names(...future.oldOptions))
[15:32:45.155]     }
[15:32:45.155]     if (FALSE) {
[15:32:45.155]     }
[15:32:45.155]     else {
[15:32:45.155]         if (TRUE) {
[15:32:45.155]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:45.155]                 open = "w")
[15:32:45.155]         }
[15:32:45.155]         else {
[15:32:45.155]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:45.155]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:45.155]         }
[15:32:45.155]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:45.155]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:45.155]             base::sink(type = "output", split = FALSE)
[15:32:45.155]             base::close(...future.stdout)
[15:32:45.155]         }, add = TRUE)
[15:32:45.155]     }
[15:32:45.155]     ...future.frame <- base::sys.nframe()
[15:32:45.155]     ...future.conditions <- base::list()
[15:32:45.155]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:45.155]     if (FALSE) {
[15:32:45.155]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:45.155]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:45.155]     }
[15:32:45.155]     ...future.result <- base::tryCatch({
[15:32:45.155]         base::withCallingHandlers({
[15:32:45.155]             ...future.value <- base::withVisible(base::local({
[15:32:45.155]                 do.call(function(...) {
[15:32:45.155]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.155]                   if (!identical(...future.globals.maxSize.org, 
[15:32:45.155]                     ...future.globals.maxSize)) {
[15:32:45.155]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.155]                     on.exit(options(oopts), add = TRUE)
[15:32:45.155]                   }
[15:32:45.155]                   {
[15:32:45.155]                     lapply(seq_along(...future.elements_ii), 
[15:32:45.155]                       FUN = function(jj) {
[15:32:45.155]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.155]                         ...future.FUN(...future.X_jj, ...)
[15:32:45.155]                       })
[15:32:45.155]                   }
[15:32:45.155]                 }, args = future.call.arguments)
[15:32:45.155]             }))
[15:32:45.155]             future::FutureResult(value = ...future.value$value, 
[15:32:45.155]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.155]                   ...future.rng), globalenv = if (FALSE) 
[15:32:45.155]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:45.155]                     ...future.globalenv.names))
[15:32:45.155]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:45.155]         }, condition = base::local({
[15:32:45.155]             c <- base::c
[15:32:45.155]             inherits <- base::inherits
[15:32:45.155]             invokeRestart <- base::invokeRestart
[15:32:45.155]             length <- base::length
[15:32:45.155]             list <- base::list
[15:32:45.155]             seq.int <- base::seq.int
[15:32:45.155]             signalCondition <- base::signalCondition
[15:32:45.155]             sys.calls <- base::sys.calls
[15:32:45.155]             `[[` <- base::`[[`
[15:32:45.155]             `+` <- base::`+`
[15:32:45.155]             `<<-` <- base::`<<-`
[15:32:45.155]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:45.155]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:45.155]                   3L)]
[15:32:45.155]             }
[15:32:45.155]             function(cond) {
[15:32:45.155]                 is_error <- inherits(cond, "error")
[15:32:45.155]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:45.155]                   NULL)
[15:32:45.155]                 if (is_error) {
[15:32:45.155]                   sessionInformation <- function() {
[15:32:45.155]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:45.155]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:45.155]                       search = base::search(), system = base::Sys.info())
[15:32:45.155]                   }
[15:32:45.155]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.155]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:45.155]                     cond$call), session = sessionInformation(), 
[15:32:45.155]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:45.155]                   signalCondition(cond)
[15:32:45.155]                 }
[15:32:45.155]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:45.155]                 "immediateCondition"))) {
[15:32:45.155]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:45.155]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.155]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:45.155]                   if (TRUE && !signal) {
[15:32:45.155]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.155]                     {
[15:32:45.155]                       inherits <- base::inherits
[15:32:45.155]                       invokeRestart <- base::invokeRestart
[15:32:45.155]                       is.null <- base::is.null
[15:32:45.155]                       muffled <- FALSE
[15:32:45.155]                       if (inherits(cond, "message")) {
[15:32:45.155]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.155]                         if (muffled) 
[15:32:45.155]                           invokeRestart("muffleMessage")
[15:32:45.155]                       }
[15:32:45.155]                       else if (inherits(cond, "warning")) {
[15:32:45.155]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.155]                         if (muffled) 
[15:32:45.155]                           invokeRestart("muffleWarning")
[15:32:45.155]                       }
[15:32:45.155]                       else if (inherits(cond, "condition")) {
[15:32:45.155]                         if (!is.null(pattern)) {
[15:32:45.155]                           computeRestarts <- base::computeRestarts
[15:32:45.155]                           grepl <- base::grepl
[15:32:45.155]                           restarts <- computeRestarts(cond)
[15:32:45.155]                           for (restart in restarts) {
[15:32:45.155]                             name <- restart$name
[15:32:45.155]                             if (is.null(name)) 
[15:32:45.155]                               next
[15:32:45.155]                             if (!grepl(pattern, name)) 
[15:32:45.155]                               next
[15:32:45.155]                             invokeRestart(restart)
[15:32:45.155]                             muffled <- TRUE
[15:32:45.155]                             break
[15:32:45.155]                           }
[15:32:45.155]                         }
[15:32:45.155]                       }
[15:32:45.155]                       invisible(muffled)
[15:32:45.155]                     }
[15:32:45.155]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.155]                   }
[15:32:45.155]                 }
[15:32:45.155]                 else {
[15:32:45.155]                   if (TRUE) {
[15:32:45.155]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.155]                     {
[15:32:45.155]                       inherits <- base::inherits
[15:32:45.155]                       invokeRestart <- base::invokeRestart
[15:32:45.155]                       is.null <- base::is.null
[15:32:45.155]                       muffled <- FALSE
[15:32:45.155]                       if (inherits(cond, "message")) {
[15:32:45.155]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.155]                         if (muffled) 
[15:32:45.155]                           invokeRestart("muffleMessage")
[15:32:45.155]                       }
[15:32:45.155]                       else if (inherits(cond, "warning")) {
[15:32:45.155]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.155]                         if (muffled) 
[15:32:45.155]                           invokeRestart("muffleWarning")
[15:32:45.155]                       }
[15:32:45.155]                       else if (inherits(cond, "condition")) {
[15:32:45.155]                         if (!is.null(pattern)) {
[15:32:45.155]                           computeRestarts <- base::computeRestarts
[15:32:45.155]                           grepl <- base::grepl
[15:32:45.155]                           restarts <- computeRestarts(cond)
[15:32:45.155]                           for (restart in restarts) {
[15:32:45.155]                             name <- restart$name
[15:32:45.155]                             if (is.null(name)) 
[15:32:45.155]                               next
[15:32:45.155]                             if (!grepl(pattern, name)) 
[15:32:45.155]                               next
[15:32:45.155]                             invokeRestart(restart)
[15:32:45.155]                             muffled <- TRUE
[15:32:45.155]                             break
[15:32:45.155]                           }
[15:32:45.155]                         }
[15:32:45.155]                       }
[15:32:45.155]                       invisible(muffled)
[15:32:45.155]                     }
[15:32:45.155]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.155]                   }
[15:32:45.155]                 }
[15:32:45.155]             }
[15:32:45.155]         }))
[15:32:45.155]     }, error = function(ex) {
[15:32:45.155]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:45.155]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.155]                 ...future.rng), started = ...future.startTime, 
[15:32:45.155]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:45.155]             version = "1.8"), class = "FutureResult")
[15:32:45.155]     }, finally = {
[15:32:45.155]         if (!identical(...future.workdir, getwd())) 
[15:32:45.155]             setwd(...future.workdir)
[15:32:45.155]         {
[15:32:45.155]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:45.155]                 ...future.oldOptions$nwarnings <- NULL
[15:32:45.155]             }
[15:32:45.155]             base::options(...future.oldOptions)
[15:32:45.155]             if (.Platform$OS.type == "windows") {
[15:32:45.155]                 old_names <- names(...future.oldEnvVars)
[15:32:45.155]                 envs <- base::Sys.getenv()
[15:32:45.155]                 names <- names(envs)
[15:32:45.155]                 common <- intersect(names, old_names)
[15:32:45.155]                 added <- setdiff(names, old_names)
[15:32:45.155]                 removed <- setdiff(old_names, names)
[15:32:45.155]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:45.155]                   envs[common]]
[15:32:45.155]                 NAMES <- toupper(changed)
[15:32:45.155]                 args <- list()
[15:32:45.155]                 for (kk in seq_along(NAMES)) {
[15:32:45.155]                   name <- changed[[kk]]
[15:32:45.155]                   NAME <- NAMES[[kk]]
[15:32:45.155]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.155]                     next
[15:32:45.155]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.155]                 }
[15:32:45.155]                 NAMES <- toupper(added)
[15:32:45.155]                 for (kk in seq_along(NAMES)) {
[15:32:45.155]                   name <- added[[kk]]
[15:32:45.155]                   NAME <- NAMES[[kk]]
[15:32:45.155]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.155]                     next
[15:32:45.155]                   args[[name]] <- ""
[15:32:45.155]                 }
[15:32:45.155]                 NAMES <- toupper(removed)
[15:32:45.155]                 for (kk in seq_along(NAMES)) {
[15:32:45.155]                   name <- removed[[kk]]
[15:32:45.155]                   NAME <- NAMES[[kk]]
[15:32:45.155]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.155]                     next
[15:32:45.155]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.155]                 }
[15:32:45.155]                 if (length(args) > 0) 
[15:32:45.155]                   base::do.call(base::Sys.setenv, args = args)
[15:32:45.155]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:45.155]             }
[15:32:45.155]             else {
[15:32:45.155]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:45.155]             }
[15:32:45.155]             {
[15:32:45.155]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:45.155]                   0L) {
[15:32:45.155]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:45.155]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:45.155]                   base::options(opts)
[15:32:45.155]                 }
[15:32:45.155]                 {
[15:32:45.155]                   {
[15:32:45.155]                     NULL
[15:32:45.155]                     RNGkind("Mersenne-Twister")
[15:32:45.155]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:45.155]                       inherits = FALSE)
[15:32:45.155]                   }
[15:32:45.155]                   options(future.plan = NULL)
[15:32:45.155]                   if (is.na(NA_character_)) 
[15:32:45.155]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.155]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:45.155]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:45.155]                     .init = FALSE)
[15:32:45.155]                 }
[15:32:45.155]             }
[15:32:45.155]         }
[15:32:45.155]     })
[15:32:45.155]     if (TRUE) {
[15:32:45.155]         base::sink(type = "output", split = FALSE)
[15:32:45.155]         if (TRUE) {
[15:32:45.155]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:45.155]         }
[15:32:45.155]         else {
[15:32:45.155]             ...future.result["stdout"] <- base::list(NULL)
[15:32:45.155]         }
[15:32:45.155]         base::close(...future.stdout)
[15:32:45.155]         ...future.stdout <- NULL
[15:32:45.155]     }
[15:32:45.155]     ...future.result$conditions <- ...future.conditions
[15:32:45.155]     ...future.result$finished <- base::Sys.time()
[15:32:45.155]     ...future.result
[15:32:45.155] }
[15:32:45.162] assign_globals() ...
[15:32:45.163] List of 11
[15:32:45.163]  $ ...future.FUN            :function (x, ...)  
[15:32:45.163]  $ x_FUN                    :function (x)  
[15:32:45.163]  $ times                    : int 4
[15:32:45.163]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.163]  $ stop_if_not              :function (...)  
[15:32:45.163]  $ dim                      : int [1:2] 2 2
[15:32:45.163]  $ valid_types              : chr [1:3] "logical" "integer" "double"
[15:32:45.163]  $ future.call.arguments    : list()
[15:32:45.163]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.163]  $ ...future.elements_ii    :List of 10
[15:32:45.163]   ..$ : int 1
[15:32:45.163]   ..$ : int 2
[15:32:45.163]   ..$ : int 3
[15:32:45.163]   ..$ : int 4
[15:32:45.163]   ..$ : int 5
[15:32:45.163]   ..$ : int 6
[15:32:45.163]   ..$ : int 7
[15:32:45.163]   ..$ : int 8
[15:32:45.163]   ..$ : int 9
[15:32:45.163]   ..$ : int 10
[15:32:45.163]  $ ...future.seeds_ii       : NULL
[15:32:45.163]  $ ...future.globals.maxSize: NULL
[15:32:45.163]  - attr(*, "where")=List of 11
[15:32:45.163]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:45.163]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:45.163]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:45.163]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:45.163]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:45.163]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:45.163]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:45.163]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:45.163]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:45.163]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:45.163]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:45.163]  - attr(*, "resolved")= logi FALSE
[15:32:45.163]  - attr(*, "total_size")= num 105552
[15:32:45.163]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.163]  - attr(*, "already-done")= logi TRUE
[15:32:45.186] - copied '...future.FUN' to environment
[15:32:45.186] - reassign environment for 'x_FUN'
[15:32:45.187] - copied 'x_FUN' to environment
[15:32:45.187] - copied 'times' to environment
[15:32:45.187] - copied 'stopf' to environment
[15:32:45.187] - copied 'stop_if_not' to environment
[15:32:45.188] - copied 'dim' to environment
[15:32:45.188] - copied 'valid_types' to environment
[15:32:45.188] - copied 'future.call.arguments' to environment
[15:32:45.188] - copied '...future.elements_ii' to environment
[15:32:45.189] - copied '...future.seeds_ii' to environment
[15:32:45.189] - copied '...future.globals.maxSize' to environment
[15:32:45.189] assign_globals() ... done
[15:32:45.190] plan(): Setting new future strategy stack:
[15:32:45.190] List of future strategies:
[15:32:45.190] 1. sequential:
[15:32:45.190]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.190]    - tweaked: FALSE
[15:32:45.190]    - call: NULL
[15:32:45.191] plan(): nbrOfWorkers() = 1
[15:32:45.193] plan(): Setting new future strategy stack:
[15:32:45.194] List of future strategies:
[15:32:45.194] 1. sequential:
[15:32:45.194]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.194]    - tweaked: FALSE
[15:32:45.194]    - call: plan(strategy)
[15:32:45.195] plan(): nbrOfWorkers() = 1
[15:32:45.195] SequentialFuture started (and completed)
[15:32:45.195] - Launch lazy future ... done
[15:32:45.196] run() for 'SequentialFuture' ... done
[15:32:45.196] Created future:
[15:32:45.196] SequentialFuture:
[15:32:45.196] Label: 'future_vapply-1'
[15:32:45.196] Expression:
[15:32:45.196] {
[15:32:45.196]     do.call(function(...) {
[15:32:45.196]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.196]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.196]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.196]             on.exit(options(oopts), add = TRUE)
[15:32:45.196]         }
[15:32:45.196]         {
[15:32:45.196]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.196]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.196]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.196]             })
[15:32:45.196]         }
[15:32:45.196]     }, args = future.call.arguments)
[15:32:45.196] }
[15:32:45.196] Lazy evaluation: FALSE
[15:32:45.196] Asynchronous evaluation: FALSE
[15:32:45.196] Local evaluation: TRUE
[15:32:45.196] Environment: R_GlobalEnv
[15:32:45.196] Capture standard output: TRUE
[15:32:45.196] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:45.196] Globals: 11 objects totaling 103.62 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 10.95 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:45.196] Packages: 1 packages ('future.apply')
[15:32:45.196] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:45.196] Resolved: TRUE
[15:32:45.196] Value: 7.42 KiB of class 'list'
[15:32:45.196] Early signaling: FALSE
[15:32:45.196] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:45.196] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.199] Chunk #1 of 1 ... DONE
[15:32:45.199] Launching 1 futures (chunks) ... DONE
[15:32:45.200] Resolving 1 futures (chunks) ...
[15:32:45.200] resolve() on list ...
[15:32:45.200]  recursive: 0
[15:32:45.201]  length: 1
[15:32:45.201] 
[15:32:45.201] resolved() for 'SequentialFuture' ...
[15:32:45.201] - state: 'finished'
[15:32:45.202] - run: TRUE
[15:32:45.202] - result: 'FutureResult'
[15:32:45.202] resolved() for 'SequentialFuture' ... done
[15:32:45.203] Future #1
[15:32:45.203] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:45.203] - nx: 1
[15:32:45.204] - relay: TRUE
[15:32:45.204] - stdout: TRUE
[15:32:45.204] - signal: TRUE
[15:32:45.204] - resignal: FALSE
[15:32:45.205] - force: TRUE
[15:32:45.205] - relayed: [n=1] FALSE
[15:32:45.205] - queued futures: [n=1] FALSE
[15:32:45.205]  - until=1
[15:32:45.206]  - relaying element #1
[15:32:45.206] - relayed: [n=1] TRUE
[15:32:45.206] - queued futures: [n=1] TRUE
[15:32:45.207] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:45.207]  length: 0 (resolved future 1)
[15:32:45.207] Relaying remaining futures
[15:32:45.207] signalConditionsASAP(NULL, pos=0) ...
[15:32:45.208] - nx: 1
[15:32:45.208] - relay: TRUE
[15:32:45.208] - stdout: TRUE
[15:32:45.208] - signal: TRUE
[15:32:45.209] - resignal: FALSE
[15:32:45.209] - force: TRUE
[15:32:45.209] - relayed: [n=1] TRUE
[15:32:45.209] - queued futures: [n=1] TRUE
 - flush all
[15:32:45.210] - relayed: [n=1] TRUE
[15:32:45.210] - queued futures: [n=1] TRUE
[15:32:45.210] signalConditionsASAP(NULL, pos=0) ... done
[15:32:45.210] resolve() on list ... DONE
[15:32:45.211]  - Number of value chunks collected: 1
[15:32:45.211] Resolving 1 futures (chunks) ... DONE
[15:32:45.211] Reducing values from 1 chunks ...
[15:32:45.212]  - Number of values collected after concatenation: 10
[15:32:45.212]  - Number of values expected: 10
[15:32:45.212] Reducing values from 1 chunks ... DONE
[15:32:45.212] future_lapply() ... DONE
 int [1:2, 1:2, 1:10] 1 1 1 1 2 2 2 2 3 3 ...
 - attr(*, "dimnames")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:2] "A" "B"
  ..$ : NULL
- From example(vapply) ...
[15:32:45.218] future_lapply() ...
[15:32:45.225] Number of chunks: 1
[15:32:45.225] getGlobalsAndPackagesXApply() ...
[15:32:45.225]  - future.globals: TRUE
[15:32:45.225] getGlobalsAndPackages() ...
[15:32:45.226] Searching for globals...
[15:32:45.232] - globals found: [17] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'UseMethod'
[15:32:45.233] Searching for globals ... DONE
[15:32:45.233] Resolving globals: FALSE
[15:32:45.234] The total size of the 7 globals is 93.29 KiB (95528 bytes)
[15:32:45.235] The total size of the 7 globals exported for future expression ('FUN()') is 93.29 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:45.236] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:45.236] - packages: [2] 'stats', 'future.apply'
[15:32:45.236] getGlobalsAndPackages() ... DONE
[15:32:45.236]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:45.237]  - needed namespaces: [n=2] 'stats', 'future.apply'
[15:32:45.237] Finding globals ... DONE
[15:32:45.237]  - use_args: TRUE
[15:32:45.237]  - Getting '...' globals ...
[15:32:45.238] resolve() on list ...
[15:32:45.238]  recursive: 0
[15:32:45.239]  length: 1
[15:32:45.239]  elements: '...'
[15:32:45.239]  length: 0 (resolved future 1)
[15:32:45.239] resolve() on list ... DONE
[15:32:45.240]    - '...' content: [n=0] 
[15:32:45.240] List of 1
[15:32:45.240]  $ ...: list()
[15:32:45.240]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.240]  - attr(*, "where")=List of 1
[15:32:45.240]   ..$ ...:<environment: 0x0000022d3e6617d8> 
[15:32:45.240]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.240]  - attr(*, "resolved")= logi TRUE
[15:32:45.240]  - attr(*, "total_size")= num NA
[15:32:45.244]  - Getting '...' globals ... DONE
[15:32:45.245] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:45.245] List of 8
[15:32:45.245]  $ ...future.FUN:function (x, ...)  
[15:32:45.245]  $ x_FUN        :function (x, ...)  
[15:32:45.245]  $ times        : int 5
[15:32:45.245]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.245]  $ stop_if_not  :function (...)  
[15:32:45.245]  $ dim          : NULL
[15:32:45.245]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:45.245]  $ ...          : list()
[15:32:45.245]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.245]  - attr(*, "where")=List of 8
[15:32:45.245]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:45.245]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:45.245]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:45.245]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:45.245]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:45.245]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:45.245]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:45.245]   ..$ ...          :<environment: 0x0000022d3e6617d8> 
[15:32:45.245]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.245]  - attr(*, "resolved")= logi FALSE
[15:32:45.245]  - attr(*, "total_size")= num 95528
[15:32:45.260] Packages to be attached in all futures: [n=2] 'stats', 'future.apply'
[15:32:45.260] getGlobalsAndPackagesXApply() ... DONE
[15:32:45.260] Number of futures (= number of chunks): 1
[15:32:45.261] Launching 1 futures (chunks) ...
[15:32:45.261] Chunk #1 of 1 ...
[15:32:45.261]  - Finding globals in 'X' for chunk #1 ...
[15:32:45.262] getGlobalsAndPackages() ...
[15:32:45.262] Searching for globals...
[15:32:45.263] 
[15:32:45.263] Searching for globals ... DONE
[15:32:45.263] - globals: [0] <none>
[15:32:45.264] getGlobalsAndPackages() ... DONE
[15:32:45.264]    + additional globals found: [n=0] 
[15:32:45.264]    + additional namespaces needed: [n=0] 
[15:32:45.264]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:45.265]  - seeds: <none>
[15:32:45.265]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.265] getGlobalsAndPackages() ...
[15:32:45.265] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.266] Resolving globals: FALSE
[15:32:45.266] Tweak future expression to call with '...' arguments ...
[15:32:45.267] {
[15:32:45.267]     do.call(function(...) {
[15:32:45.267]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.267]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.267]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.267]             on.exit(options(oopts), add = TRUE)
[15:32:45.267]         }
[15:32:45.267]         {
[15:32:45.267]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.267]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.267]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.267]             })
[15:32:45.267]         }
[15:32:45.267]     }, args = future.call.arguments)
[15:32:45.267] }
[15:32:45.267] Tweak future expression to call with '...' arguments ... DONE
[15:32:45.268] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.269] - packages: [2] 'stats', 'future.apply'
[15:32:45.269] getGlobalsAndPackages() ... DONE
[15:32:45.270] run() for 'Future' ...
[15:32:45.270] - state: 'created'
[15:32:45.270] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:45.271] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.271] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:45.272]   - Field: 'label'
[15:32:45.272]   - Field: 'local'
[15:32:45.272]   - Field: 'owner'
[15:32:45.273]   - Field: 'envir'
[15:32:45.273]   - Field: 'packages'
[15:32:45.273]   - Field: 'gc'
[15:32:45.273]   - Field: 'conditions'
[15:32:45.274]   - Field: 'expr'
[15:32:45.274]   - Field: 'uuid'
[15:32:45.274]   - Field: 'seed'
[15:32:45.275]   - Field: 'version'
[15:32:45.275]   - Field: 'result'
[15:32:45.275]   - Field: 'asynchronous'
[15:32:45.275]   - Field: 'calls'
[15:32:45.276]   - Field: 'globals'
[15:32:45.276]   - Field: 'stdout'
[15:32:45.276]   - Field: 'earlySignal'
[15:32:45.276]   - Field: 'lazy'
[15:32:45.277]   - Field: 'state'
[15:32:45.277] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:45.277] - Launch lazy future ...
[15:32:45.278] Packages needed by the future expression (n = 2): 'stats', 'future.apply'
[15:32:45.278] Packages needed by future strategies (n = 0): <none>
[15:32:45.279] {
[15:32:45.279]     {
[15:32:45.279]         {
[15:32:45.279]             ...future.startTime <- base::Sys.time()
[15:32:45.279]             {
[15:32:45.279]                 {
[15:32:45.279]                   {
[15:32:45.279]                     {
[15:32:45.279]                       base::local({
[15:32:45.279]                         has_future <- base::requireNamespace("future", 
[15:32:45.279]                           quietly = TRUE)
[15:32:45.279]                         if (has_future) {
[15:32:45.279]                           ns <- base::getNamespace("future")
[15:32:45.279]                           version <- ns[[".package"]][["version"]]
[15:32:45.279]                           if (is.null(version)) 
[15:32:45.279]                             version <- utils::packageVersion("future")
[15:32:45.279]                         }
[15:32:45.279]                         else {
[15:32:45.279]                           version <- NULL
[15:32:45.279]                         }
[15:32:45.279]                         if (!has_future || version < "1.8.0") {
[15:32:45.279]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:45.279]                             "", base::R.version$version.string), 
[15:32:45.279]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:45.279]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:45.279]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:45.279]                               "release", "version")], collapse = " "), 
[15:32:45.279]                             hostname = base::Sys.info()[["nodename"]])
[15:32:45.279]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:45.279]                             info)
[15:32:45.279]                           info <- base::paste(info, collapse = "; ")
[15:32:45.279]                           if (!has_future) {
[15:32:45.279]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:45.279]                               info)
[15:32:45.279]                           }
[15:32:45.279]                           else {
[15:32:45.279]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:45.279]                               info, version)
[15:32:45.279]                           }
[15:32:45.279]                           base::stop(msg)
[15:32:45.279]                         }
[15:32:45.279]                       })
[15:32:45.279]                     }
[15:32:45.279]                     base::local({
[15:32:45.279]                       for (pkg in c("stats", "future.apply")) {
[15:32:45.279]                         base::loadNamespace(pkg)
[15:32:45.279]                         base::library(pkg, character.only = TRUE)
[15:32:45.279]                       }
[15:32:45.279]                     })
[15:32:45.279]                   }
[15:32:45.279]                   ...future.strategy.old <- future::plan("list")
[15:32:45.279]                   options(future.plan = NULL)
[15:32:45.279]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.279]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:45.279]                 }
[15:32:45.279]                 ...future.workdir <- getwd()
[15:32:45.279]             }
[15:32:45.279]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:45.279]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:45.279]         }
[15:32:45.279]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:45.279]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:45.279]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:45.279]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:45.279]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:45.279]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:45.279]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:45.279]             base::names(...future.oldOptions))
[15:32:45.279]     }
[15:32:45.279]     if (FALSE) {
[15:32:45.279]     }
[15:32:45.279]     else {
[15:32:45.279]         if (TRUE) {
[15:32:45.279]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:45.279]                 open = "w")
[15:32:45.279]         }
[15:32:45.279]         else {
[15:32:45.279]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:45.279]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:45.279]         }
[15:32:45.279]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:45.279]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:45.279]             base::sink(type = "output", split = FALSE)
[15:32:45.279]             base::close(...future.stdout)
[15:32:45.279]         }, add = TRUE)
[15:32:45.279]     }
[15:32:45.279]     ...future.frame <- base::sys.nframe()
[15:32:45.279]     ...future.conditions <- base::list()
[15:32:45.279]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:45.279]     if (FALSE) {
[15:32:45.279]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:45.279]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:45.279]     }
[15:32:45.279]     ...future.result <- base::tryCatch({
[15:32:45.279]         base::withCallingHandlers({
[15:32:45.279]             ...future.value <- base::withVisible(base::local({
[15:32:45.279]                 do.call(function(...) {
[15:32:45.279]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.279]                   if (!identical(...future.globals.maxSize.org, 
[15:32:45.279]                     ...future.globals.maxSize)) {
[15:32:45.279]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.279]                     on.exit(options(oopts), add = TRUE)
[15:32:45.279]                   }
[15:32:45.279]                   {
[15:32:45.279]                     lapply(seq_along(...future.elements_ii), 
[15:32:45.279]                       FUN = function(jj) {
[15:32:45.279]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.279]                         ...future.FUN(...future.X_jj, ...)
[15:32:45.279]                       })
[15:32:45.279]                   }
[15:32:45.279]                 }, args = future.call.arguments)
[15:32:45.279]             }))
[15:32:45.279]             future::FutureResult(value = ...future.value$value, 
[15:32:45.279]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.279]                   ...future.rng), globalenv = if (FALSE) 
[15:32:45.279]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:45.279]                     ...future.globalenv.names))
[15:32:45.279]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:45.279]         }, condition = base::local({
[15:32:45.279]             c <- base::c
[15:32:45.279]             inherits <- base::inherits
[15:32:45.279]             invokeRestart <- base::invokeRestart
[15:32:45.279]             length <- base::length
[15:32:45.279]             list <- base::list
[15:32:45.279]             seq.int <- base::seq.int
[15:32:45.279]             signalCondition <- base::signalCondition
[15:32:45.279]             sys.calls <- base::sys.calls
[15:32:45.279]             `[[` <- base::`[[`
[15:32:45.279]             `+` <- base::`+`
[15:32:45.279]             `<<-` <- base::`<<-`
[15:32:45.279]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:45.279]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:45.279]                   3L)]
[15:32:45.279]             }
[15:32:45.279]             function(cond) {
[15:32:45.279]                 is_error <- inherits(cond, "error")
[15:32:45.279]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:45.279]                   NULL)
[15:32:45.279]                 if (is_error) {
[15:32:45.279]                   sessionInformation <- function() {
[15:32:45.279]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:45.279]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:45.279]                       search = base::search(), system = base::Sys.info())
[15:32:45.279]                   }
[15:32:45.279]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.279]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:45.279]                     cond$call), session = sessionInformation(), 
[15:32:45.279]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:45.279]                   signalCondition(cond)
[15:32:45.279]                 }
[15:32:45.279]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:45.279]                 "immediateCondition"))) {
[15:32:45.279]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:45.279]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.279]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:45.279]                   if (TRUE && !signal) {
[15:32:45.279]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.279]                     {
[15:32:45.279]                       inherits <- base::inherits
[15:32:45.279]                       invokeRestart <- base::invokeRestart
[15:32:45.279]                       is.null <- base::is.null
[15:32:45.279]                       muffled <- FALSE
[15:32:45.279]                       if (inherits(cond, "message")) {
[15:32:45.279]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.279]                         if (muffled) 
[15:32:45.279]                           invokeRestart("muffleMessage")
[15:32:45.279]                       }
[15:32:45.279]                       else if (inherits(cond, "warning")) {
[15:32:45.279]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.279]                         if (muffled) 
[15:32:45.279]                           invokeRestart("muffleWarning")
[15:32:45.279]                       }
[15:32:45.279]                       else if (inherits(cond, "condition")) {
[15:32:45.279]                         if (!is.null(pattern)) {
[15:32:45.279]                           computeRestarts <- base::computeRestarts
[15:32:45.279]                           grepl <- base::grepl
[15:32:45.279]                           restarts <- computeRestarts(cond)
[15:32:45.279]                           for (restart in restarts) {
[15:32:45.279]                             name <- restart$name
[15:32:45.279]                             if (is.null(name)) 
[15:32:45.279]                               next
[15:32:45.279]                             if (!grepl(pattern, name)) 
[15:32:45.279]                               next
[15:32:45.279]                             invokeRestart(restart)
[15:32:45.279]                             muffled <- TRUE
[15:32:45.279]                             break
[15:32:45.279]                           }
[15:32:45.279]                         }
[15:32:45.279]                       }
[15:32:45.279]                       invisible(muffled)
[15:32:45.279]                     }
[15:32:45.279]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.279]                   }
[15:32:45.279]                 }
[15:32:45.279]                 else {
[15:32:45.279]                   if (TRUE) {
[15:32:45.279]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.279]                     {
[15:32:45.279]                       inherits <- base::inherits
[15:32:45.279]                       invokeRestart <- base::invokeRestart
[15:32:45.279]                       is.null <- base::is.null
[15:32:45.279]                       muffled <- FALSE
[15:32:45.279]                       if (inherits(cond, "message")) {
[15:32:45.279]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.279]                         if (muffled) 
[15:32:45.279]                           invokeRestart("muffleMessage")
[15:32:45.279]                       }
[15:32:45.279]                       else if (inherits(cond, "warning")) {
[15:32:45.279]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.279]                         if (muffled) 
[15:32:45.279]                           invokeRestart("muffleWarning")
[15:32:45.279]                       }
[15:32:45.279]                       else if (inherits(cond, "condition")) {
[15:32:45.279]                         if (!is.null(pattern)) {
[15:32:45.279]                           computeRestarts <- base::computeRestarts
[15:32:45.279]                           grepl <- base::grepl
[15:32:45.279]                           restarts <- computeRestarts(cond)
[15:32:45.279]                           for (restart in restarts) {
[15:32:45.279]                             name <- restart$name
[15:32:45.279]                             if (is.null(name)) 
[15:32:45.279]                               next
[15:32:45.279]                             if (!grepl(pattern, name)) 
[15:32:45.279]                               next
[15:32:45.279]                             invokeRestart(restart)
[15:32:45.279]                             muffled <- TRUE
[15:32:45.279]                             break
[15:32:45.279]                           }
[15:32:45.279]                         }
[15:32:45.279]                       }
[15:32:45.279]                       invisible(muffled)
[15:32:45.279]                     }
[15:32:45.279]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.279]                   }
[15:32:45.279]                 }
[15:32:45.279]             }
[15:32:45.279]         }))
[15:32:45.279]     }, error = function(ex) {
[15:32:45.279]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:45.279]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.279]                 ...future.rng), started = ...future.startTime, 
[15:32:45.279]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:45.279]             version = "1.8"), class = "FutureResult")
[15:32:45.279]     }, finally = {
[15:32:45.279]         if (!identical(...future.workdir, getwd())) 
[15:32:45.279]             setwd(...future.workdir)
[15:32:45.279]         {
[15:32:45.279]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:45.279]                 ...future.oldOptions$nwarnings <- NULL
[15:32:45.279]             }
[15:32:45.279]             base::options(...future.oldOptions)
[15:32:45.279]             if (.Platform$OS.type == "windows") {
[15:32:45.279]                 old_names <- names(...future.oldEnvVars)
[15:32:45.279]                 envs <- base::Sys.getenv()
[15:32:45.279]                 names <- names(envs)
[15:32:45.279]                 common <- intersect(names, old_names)
[15:32:45.279]                 added <- setdiff(names, old_names)
[15:32:45.279]                 removed <- setdiff(old_names, names)
[15:32:45.279]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:45.279]                   envs[common]]
[15:32:45.279]                 NAMES <- toupper(changed)
[15:32:45.279]                 args <- list()
[15:32:45.279]                 for (kk in seq_along(NAMES)) {
[15:32:45.279]                   name <- changed[[kk]]
[15:32:45.279]                   NAME <- NAMES[[kk]]
[15:32:45.279]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.279]                     next
[15:32:45.279]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.279]                 }
[15:32:45.279]                 NAMES <- toupper(added)
[15:32:45.279]                 for (kk in seq_along(NAMES)) {
[15:32:45.279]                   name <- added[[kk]]
[15:32:45.279]                   NAME <- NAMES[[kk]]
[15:32:45.279]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.279]                     next
[15:32:45.279]                   args[[name]] <- ""
[15:32:45.279]                 }
[15:32:45.279]                 NAMES <- toupper(removed)
[15:32:45.279]                 for (kk in seq_along(NAMES)) {
[15:32:45.279]                   name <- removed[[kk]]
[15:32:45.279]                   NAME <- NAMES[[kk]]
[15:32:45.279]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.279]                     next
[15:32:45.279]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.279]                 }
[15:32:45.279]                 if (length(args) > 0) 
[15:32:45.279]                   base::do.call(base::Sys.setenv, args = args)
[15:32:45.279]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:45.279]             }
[15:32:45.279]             else {
[15:32:45.279]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:45.279]             }
[15:32:45.279]             {
[15:32:45.279]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:45.279]                   0L) {
[15:32:45.279]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:45.279]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:45.279]                   base::options(opts)
[15:32:45.279]                 }
[15:32:45.279]                 {
[15:32:45.279]                   {
[15:32:45.279]                     NULL
[15:32:45.279]                     RNGkind("Mersenne-Twister")
[15:32:45.279]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:45.279]                       inherits = FALSE)
[15:32:45.279]                   }
[15:32:45.279]                   options(future.plan = NULL)
[15:32:45.279]                   if (is.na(NA_character_)) 
[15:32:45.279]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.279]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:45.279]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:45.279]                     .init = FALSE)
[15:32:45.279]                 }
[15:32:45.279]             }
[15:32:45.279]         }
[15:32:45.279]     })
[15:32:45.279]     if (TRUE) {
[15:32:45.279]         base::sink(type = "output", split = FALSE)
[15:32:45.279]         if (TRUE) {
[15:32:45.279]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:45.279]         }
[15:32:45.279]         else {
[15:32:45.279]             ...future.result["stdout"] <- base::list(NULL)
[15:32:45.279]         }
[15:32:45.279]         base::close(...future.stdout)
[15:32:45.279]         ...future.stdout <- NULL
[15:32:45.279]     }
[15:32:45.279]     ...future.result$conditions <- ...future.conditions
[15:32:45.279]     ...future.result$finished <- base::Sys.time()
[15:32:45.279]     ...future.result
[15:32:45.279] }
[15:32:45.285] assign_globals() ...
[15:32:45.285] List of 11
[15:32:45.285]  $ ...future.FUN            :function (x, ...)  
[15:32:45.285]  $ x_FUN                    :function (x, ...)  
[15:32:45.285]  $ times                    : int 5
[15:32:45.285]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.285]  $ stop_if_not              :function (...)  
[15:32:45.285]  $ dim                      : NULL
[15:32:45.285]  $ valid_types              : chr [1:3] "logical" "integer" "double"
[15:32:45.285]  $ future.call.arguments    : list()
[15:32:45.285]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.285]  $ ...future.elements_ii    :List of 3
[15:32:45.285]   ..$ a    : int [1:10] 1 2 3 4 5 6 7 8 9 10
[15:32:45.285]   ..$ beta : num [1:7] 0.0498 0.1353 0.3679 1 2.7183 ...
[15:32:45.285]   ..$ logic: logi [1:4] TRUE FALSE FALSE TRUE
[15:32:45.285]  $ ...future.seeds_ii       : NULL
[15:32:45.285]  $ ...future.globals.maxSize: NULL
[15:32:45.285]  - attr(*, "where")=List of 11
[15:32:45.285]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:45.285]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:45.285]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:45.285]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:45.285]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:45.285]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:45.285]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:45.285]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:45.285]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:45.285]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:45.285]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:45.285]  - attr(*, "resolved")= logi FALSE
[15:32:45.285]  - attr(*, "total_size")= num 95528
[15:32:45.285]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.285]  - attr(*, "already-done")= logi TRUE
[15:32:45.304] - copied '...future.FUN' to environment
[15:32:45.304] - copied 'x_FUN' to environment
[15:32:45.304] - copied 'times' to environment
[15:32:45.304] - copied 'stopf' to environment
[15:32:45.305] - copied 'stop_if_not' to environment
[15:32:45.305] - copied 'dim' to environment
[15:32:45.305] - copied 'valid_types' to environment
[15:32:45.306] - copied 'future.call.arguments' to environment
[15:32:45.306] - copied '...future.elements_ii' to environment
[15:32:45.306] - copied '...future.seeds_ii' to environment
[15:32:45.306] - copied '...future.globals.maxSize' to environment
[15:32:45.307] assign_globals() ... done
[15:32:45.308] plan(): Setting new future strategy stack:
[15:32:45.308] List of future strategies:
[15:32:45.308] 1. sequential:
[15:32:45.308]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.308]    - tweaked: FALSE
[15:32:45.308]    - call: NULL
[15:32:45.309] plan(): nbrOfWorkers() = 1
[15:32:45.312] plan(): Setting new future strategy stack:
[15:32:45.312] List of future strategies:
[15:32:45.312] 1. sequential:
[15:32:45.312]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.312]    - tweaked: FALSE
[15:32:45.312]    - call: plan(strategy)
[15:32:45.314] plan(): nbrOfWorkers() = 1
[15:32:45.314] SequentialFuture started (and completed)
[15:32:45.314] - Launch lazy future ... done
[15:32:45.315] run() for 'SequentialFuture' ... done
[15:32:45.315] Created future:
[15:32:45.315] SequentialFuture:
[15:32:45.315] Label: 'future_vapply-1'
[15:32:45.315] Expression:
[15:32:45.315] {
[15:32:45.315]     do.call(function(...) {
[15:32:45.315]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.315]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.315]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.315]             on.exit(options(oopts), add = TRUE)
[15:32:45.315]         }
[15:32:45.315]         {
[15:32:45.315]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.315]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.315]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.315]             })
[15:32:45.315]         }
[15:32:45.315]     }, args = future.call.arguments)
[15:32:45.315] }
[15:32:45.315] Lazy evaluation: FALSE
[15:32:45.315] Asynchronous evaluation: FALSE
[15:32:45.315] Local evaluation: TRUE
[15:32:45.315] Environment: R_GlobalEnv
[15:32:45.315] Capture standard output: TRUE
[15:32:45.315] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:45.315] Globals: 11 objects totaling 93.55 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 1.22 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:45.315] Packages: 2 packages ('stats', 'future.apply')
[15:32:45.315] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:45.315] Resolved: TRUE
[15:32:45.315] Value: 1.71 KiB of class 'list'
[15:32:45.315] Early signaling: FALSE
[15:32:45.315] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:45.315] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.318] Chunk #1 of 1 ... DONE
[15:32:45.318] Launching 1 futures (chunks) ... DONE
[15:32:45.318] Resolving 1 futures (chunks) ...
[15:32:45.319] resolve() on list ...
[15:32:45.319]  recursive: 0
[15:32:45.319]  length: 1
[15:32:45.319] 
[15:32:45.320] resolved() for 'SequentialFuture' ...
[15:32:45.320] - state: 'finished'
[15:32:45.320] - run: TRUE
[15:32:45.321] - result: 'FutureResult'
[15:32:45.321] resolved() for 'SequentialFuture' ... done
[15:32:45.321] Future #1
[15:32:45.322] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:45.322] - nx: 1
[15:32:45.322] - relay: TRUE
[15:32:45.322] - stdout: TRUE
[15:32:45.323] - signal: TRUE
[15:32:45.323] - resignal: FALSE
[15:32:45.323] - force: TRUE
[15:32:45.323] - relayed: [n=1] FALSE
[15:32:45.324] - queued futures: [n=1] FALSE
[15:32:45.324]  - until=1
[15:32:45.324]  - relaying element #1
[15:32:45.325] - relayed: [n=1] TRUE
[15:32:45.325] - queued futures: [n=1] TRUE
[15:32:45.325] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:45.326]  length: 0 (resolved future 1)
[15:32:45.326] Relaying remaining futures
[15:32:45.326] signalConditionsASAP(NULL, pos=0) ...
[15:32:45.326] - nx: 1
[15:32:45.327] - relay: TRUE
[15:32:45.327] - stdout: TRUE
[15:32:45.327] - signal: TRUE
[15:32:45.327] - resignal: FALSE
[15:32:45.328] - force: TRUE
[15:32:45.328] - relayed: [n=1] TRUE
[15:32:45.328] - queued futures: [n=1] TRUE
 - flush all
[15:32:45.328] - relayed: [n=1] TRUE
[15:32:45.328] - queued futures: [n=1] TRUE
[15:32:45.329] signalConditionsASAP(NULL, pos=0) ... done
[15:32:45.329] resolve() on list ... DONE
[15:32:45.329]  - Number of value chunks collected: 1
[15:32:45.329] Resolving 1 futures (chunks) ... DONE
[15:32:45.329] Reducing values from 1 chunks ...
[15:32:45.329]  - Number of values collected after concatenation: 3
[15:32:45.330]  - Number of values expected: 3
[15:32:45.330] Reducing values from 1 chunks ... DONE
[15:32:45.330] future_lapply() ... DONE
 num [1:5, 1:3] 1 3.25 5.5 7.75 10 ...
 - attr(*, "dimnames")=List of 2
  ..$ : chr [1:5] "0%" "25%" "50%" "75%" ...
  ..$ : chr [1:3] "a" "beta" "logic"
[15:32:45.332] future_lapply() ...
[15:32:45.341] Number of chunks: 1
[15:32:45.342] getGlobalsAndPackagesXApply() ...
[15:32:45.342]  - future.globals: TRUE
[15:32:45.342] getGlobalsAndPackages() ...
[15:32:45.342] Searching for globals...
[15:32:45.349] - globals found: [21] 'FUN', '{', '<-', 'is.na', 'if', 'any', '[', '!', 'return', 'rep.int', 'sort', 'length', '==', '/', 'floor', '(', '+', 'c', '-', '*', 'ceiling'
[15:32:45.350] Searching for globals ... DONE
[15:32:45.350] Resolving globals: FALSE
[15:32:45.351] The total size of the 1 globals is 45.86 KiB (46960 bytes)
[15:32:45.352] The total size of the 1 globals exported for future expression ('FUN()') is 45.86 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (45.86 KiB of class 'function')
[15:32:45.352] - globals: [1] 'FUN'
[15:32:45.352] - packages: [1] 'stats'
[15:32:45.353] getGlobalsAndPackages() ... DONE
[15:32:45.353]  - globals found/used: [n=1] 'FUN'
[15:32:45.353]  - needed namespaces: [n=1] 'stats'
[15:32:45.354] Finding globals ... DONE
[15:32:45.354]  - use_args: TRUE
[15:32:45.354]  - Getting '...' globals ...
[15:32:45.355] resolve() on list ...
[15:32:45.355]  recursive: 0
[15:32:45.355]  length: 1
[15:32:45.356]  elements: '...'
[15:32:45.356]  length: 0 (resolved future 1)
[15:32:45.356] resolve() on list ... DONE
[15:32:45.357]    - '...' content: [n=0] 
[15:32:45.357] List of 1
[15:32:45.357]  $ ...: list()
[15:32:45.357]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.357]  - attr(*, "where")=List of 1
[15:32:45.357]   ..$ ...:<environment: 0x0000022d3e3b29d0> 
[15:32:45.357]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.357]  - attr(*, "resolved")= logi TRUE
[15:32:45.357]  - attr(*, "total_size")= num NA
[15:32:45.362]  - Getting '...' globals ... DONE
[15:32:45.363] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:45.363] List of 2
[15:32:45.363]  $ ...future.FUN:function (x, na.rm = TRUE)  
[15:32:45.363]  $ ...          : list()
[15:32:45.363]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.363]  - attr(*, "where")=List of 2
[15:32:45.363]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:45.363]   ..$ ...          :<environment: 0x0000022d3e3b29d0> 
[15:32:45.363]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.363]  - attr(*, "resolved")= logi FALSE
[15:32:45.363]  - attr(*, "total_size")= num 46960
[15:32:45.373] Packages to be attached in all futures: [n=1] 'stats'
[15:32:45.373] getGlobalsAndPackagesXApply() ... DONE
[15:32:45.374] Number of futures (= number of chunks): 1
[15:32:45.374] Launching 1 futures (chunks) ...
[15:32:45.375] Chunk #1 of 1 ...
[15:32:45.375]  - Finding globals in 'X' for chunk #1 ...
[15:32:45.375] getGlobalsAndPackages() ...
[15:32:45.376] Searching for globals...
[15:32:45.376] 
[15:32:45.377] Searching for globals ... DONE
[15:32:45.377] - globals: [0] <none>
[15:32:45.377] getGlobalsAndPackages() ... DONE
[15:32:45.377]    + additional globals found: [n=0] 
[15:32:45.378]    + additional namespaces needed: [n=0] 
[15:32:45.378]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:45.378]  - seeds: <none>
[15:32:45.379]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.379] getGlobalsAndPackages() ...
[15:32:45.379] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.380] Resolving globals: FALSE
[15:32:45.380] Tweak future expression to call with '...' arguments ...
[15:32:45.380] {
[15:32:45.380]     do.call(function(...) {
[15:32:45.380]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.380]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.380]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.380]             on.exit(options(oopts), add = TRUE)
[15:32:45.380]         }
[15:32:45.380]         {
[15:32:45.380]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.380]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.380]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.380]             })
[15:32:45.380]         }
[15:32:45.380]     }, args = future.call.arguments)
[15:32:45.380] }
[15:32:45.381] Tweak future expression to call with '...' arguments ... DONE
[15:32:45.382] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.382] - packages: [1] 'stats'
[15:32:45.383] getGlobalsAndPackages() ... DONE
[15:32:45.383] run() for 'Future' ...
[15:32:45.384] - state: 'created'
[15:32:45.384] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:45.385] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.385] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:45.386]   - Field: 'label'
[15:32:45.386]   - Field: 'local'
[15:32:45.386]   - Field: 'owner'
[15:32:45.387]   - Field: 'envir'
[15:32:45.387]   - Field: 'packages'
[15:32:45.387]   - Field: 'gc'
[15:32:45.388]   - Field: 'conditions'
[15:32:45.388]   - Field: 'expr'
[15:32:45.388]   - Field: 'uuid'
[15:32:45.389]   - Field: 'seed'
[15:32:45.389]   - Field: 'version'
[15:32:45.389]   - Field: 'result'
[15:32:45.390]   - Field: 'asynchronous'
[15:32:45.390]   - Field: 'calls'
[15:32:45.390]   - Field: 'globals'
[15:32:45.391]   - Field: 'stdout'
[15:32:45.391]   - Field: 'earlySignal'
[15:32:45.391]   - Field: 'lazy'
[15:32:45.392]   - Field: 'state'
[15:32:45.392] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:45.392] - Launch lazy future ...
[15:32:45.393] Packages needed by the future expression (n = 1): 'stats'
[15:32:45.393] Packages needed by future strategies (n = 0): <none>
[15:32:45.394] {
[15:32:45.394]     {
[15:32:45.394]         {
[15:32:45.394]             ...future.startTime <- base::Sys.time()
[15:32:45.394]             {
[15:32:45.394]                 {
[15:32:45.394]                   {
[15:32:45.394]                     {
[15:32:45.394]                       base::local({
[15:32:45.394]                         has_future <- base::requireNamespace("future", 
[15:32:45.394]                           quietly = TRUE)
[15:32:45.394]                         if (has_future) {
[15:32:45.394]                           ns <- base::getNamespace("future")
[15:32:45.394]                           version <- ns[[".package"]][["version"]]
[15:32:45.394]                           if (is.null(version)) 
[15:32:45.394]                             version <- utils::packageVersion("future")
[15:32:45.394]                         }
[15:32:45.394]                         else {
[15:32:45.394]                           version <- NULL
[15:32:45.394]                         }
[15:32:45.394]                         if (!has_future || version < "1.8.0") {
[15:32:45.394]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:45.394]                             "", base::R.version$version.string), 
[15:32:45.394]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:45.394]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:45.394]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:45.394]                               "release", "version")], collapse = " "), 
[15:32:45.394]                             hostname = base::Sys.info()[["nodename"]])
[15:32:45.394]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:45.394]                             info)
[15:32:45.394]                           info <- base::paste(info, collapse = "; ")
[15:32:45.394]                           if (!has_future) {
[15:32:45.394]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:45.394]                               info)
[15:32:45.394]                           }
[15:32:45.394]                           else {
[15:32:45.394]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:45.394]                               info, version)
[15:32:45.394]                           }
[15:32:45.394]                           base::stop(msg)
[15:32:45.394]                         }
[15:32:45.394]                       })
[15:32:45.394]                     }
[15:32:45.394]                     base::local({
[15:32:45.394]                       for (pkg in "stats") {
[15:32:45.394]                         base::loadNamespace(pkg)
[15:32:45.394]                         base::library(pkg, character.only = TRUE)
[15:32:45.394]                       }
[15:32:45.394]                     })
[15:32:45.394]                   }
[15:32:45.394]                   ...future.strategy.old <- future::plan("list")
[15:32:45.394]                   options(future.plan = NULL)
[15:32:45.394]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.394]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:45.394]                 }
[15:32:45.394]                 ...future.workdir <- getwd()
[15:32:45.394]             }
[15:32:45.394]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:45.394]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:45.394]         }
[15:32:45.394]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:45.394]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:45.394]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:45.394]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:45.394]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:45.394]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:45.394]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:45.394]             base::names(...future.oldOptions))
[15:32:45.394]     }
[15:32:45.394]     if (FALSE) {
[15:32:45.394]     }
[15:32:45.394]     else {
[15:32:45.394]         if (TRUE) {
[15:32:45.394]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:45.394]                 open = "w")
[15:32:45.394]         }
[15:32:45.394]         else {
[15:32:45.394]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:45.394]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:45.394]         }
[15:32:45.394]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:45.394]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:45.394]             base::sink(type = "output", split = FALSE)
[15:32:45.394]             base::close(...future.stdout)
[15:32:45.394]         }, add = TRUE)
[15:32:45.394]     }
[15:32:45.394]     ...future.frame <- base::sys.nframe()
[15:32:45.394]     ...future.conditions <- base::list()
[15:32:45.394]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:45.394]     if (FALSE) {
[15:32:45.394]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:45.394]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:45.394]     }
[15:32:45.394]     ...future.result <- base::tryCatch({
[15:32:45.394]         base::withCallingHandlers({
[15:32:45.394]             ...future.value <- base::withVisible(base::local({
[15:32:45.394]                 do.call(function(...) {
[15:32:45.394]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.394]                   if (!identical(...future.globals.maxSize.org, 
[15:32:45.394]                     ...future.globals.maxSize)) {
[15:32:45.394]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.394]                     on.exit(options(oopts), add = TRUE)
[15:32:45.394]                   }
[15:32:45.394]                   {
[15:32:45.394]                     lapply(seq_along(...future.elements_ii), 
[15:32:45.394]                       FUN = function(jj) {
[15:32:45.394]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.394]                         ...future.FUN(...future.X_jj, ...)
[15:32:45.394]                       })
[15:32:45.394]                   }
[15:32:45.394]                 }, args = future.call.arguments)
[15:32:45.394]             }))
[15:32:45.394]             future::FutureResult(value = ...future.value$value, 
[15:32:45.394]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.394]                   ...future.rng), globalenv = if (FALSE) 
[15:32:45.394]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:45.394]                     ...future.globalenv.names))
[15:32:45.394]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:45.394]         }, condition = base::local({
[15:32:45.394]             c <- base::c
[15:32:45.394]             inherits <- base::inherits
[15:32:45.394]             invokeRestart <- base::invokeRestart
[15:32:45.394]             length <- base::length
[15:32:45.394]             list <- base::list
[15:32:45.394]             seq.int <- base::seq.int
[15:32:45.394]             signalCondition <- base::signalCondition
[15:32:45.394]             sys.calls <- base::sys.calls
[15:32:45.394]             `[[` <- base::`[[`
[15:32:45.394]             `+` <- base::`+`
[15:32:45.394]             `<<-` <- base::`<<-`
[15:32:45.394]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:45.394]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:45.394]                   3L)]
[15:32:45.394]             }
[15:32:45.394]             function(cond) {
[15:32:45.394]                 is_error <- inherits(cond, "error")
[15:32:45.394]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:45.394]                   NULL)
[15:32:45.394]                 if (is_error) {
[15:32:45.394]                   sessionInformation <- function() {
[15:32:45.394]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:45.394]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:45.394]                       search = base::search(), system = base::Sys.info())
[15:32:45.394]                   }
[15:32:45.394]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.394]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:45.394]                     cond$call), session = sessionInformation(), 
[15:32:45.394]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:45.394]                   signalCondition(cond)
[15:32:45.394]                 }
[15:32:45.394]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:45.394]                 "immediateCondition"))) {
[15:32:45.394]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:45.394]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.394]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:45.394]                   if (TRUE && !signal) {
[15:32:45.394]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.394]                     {
[15:32:45.394]                       inherits <- base::inherits
[15:32:45.394]                       invokeRestart <- base::invokeRestart
[15:32:45.394]                       is.null <- base::is.null
[15:32:45.394]                       muffled <- FALSE
[15:32:45.394]                       if (inherits(cond, "message")) {
[15:32:45.394]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.394]                         if (muffled) 
[15:32:45.394]                           invokeRestart("muffleMessage")
[15:32:45.394]                       }
[15:32:45.394]                       else if (inherits(cond, "warning")) {
[15:32:45.394]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.394]                         if (muffled) 
[15:32:45.394]                           invokeRestart("muffleWarning")
[15:32:45.394]                       }
[15:32:45.394]                       else if (inherits(cond, "condition")) {
[15:32:45.394]                         if (!is.null(pattern)) {
[15:32:45.394]                           computeRestarts <- base::computeRestarts
[15:32:45.394]                           grepl <- base::grepl
[15:32:45.394]                           restarts <- computeRestarts(cond)
[15:32:45.394]                           for (restart in restarts) {
[15:32:45.394]                             name <- restart$name
[15:32:45.394]                             if (is.null(name)) 
[15:32:45.394]                               next
[15:32:45.394]                             if (!grepl(pattern, name)) 
[15:32:45.394]                               next
[15:32:45.394]                             invokeRestart(restart)
[15:32:45.394]                             muffled <- TRUE
[15:32:45.394]                             break
[15:32:45.394]                           }
[15:32:45.394]                         }
[15:32:45.394]                       }
[15:32:45.394]                       invisible(muffled)
[15:32:45.394]                     }
[15:32:45.394]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.394]                   }
[15:32:45.394]                 }
[15:32:45.394]                 else {
[15:32:45.394]                   if (TRUE) {
[15:32:45.394]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.394]                     {
[15:32:45.394]                       inherits <- base::inherits
[15:32:45.394]                       invokeRestart <- base::invokeRestart
[15:32:45.394]                       is.null <- base::is.null
[15:32:45.394]                       muffled <- FALSE
[15:32:45.394]                       if (inherits(cond, "message")) {
[15:32:45.394]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.394]                         if (muffled) 
[15:32:45.394]                           invokeRestart("muffleMessage")
[15:32:45.394]                       }
[15:32:45.394]                       else if (inherits(cond, "warning")) {
[15:32:45.394]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.394]                         if (muffled) 
[15:32:45.394]                           invokeRestart("muffleWarning")
[15:32:45.394]                       }
[15:32:45.394]                       else if (inherits(cond, "condition")) {
[15:32:45.394]                         if (!is.null(pattern)) {
[15:32:45.394]                           computeRestarts <- base::computeRestarts
[15:32:45.394]                           grepl <- base::grepl
[15:32:45.394]                           restarts <- computeRestarts(cond)
[15:32:45.394]                           for (restart in restarts) {
[15:32:45.394]                             name <- restart$name
[15:32:45.394]                             if (is.null(name)) 
[15:32:45.394]                               next
[15:32:45.394]                             if (!grepl(pattern, name)) 
[15:32:45.394]                               next
[15:32:45.394]                             invokeRestart(restart)
[15:32:45.394]                             muffled <- TRUE
[15:32:45.394]                             break
[15:32:45.394]                           }
[15:32:45.394]                         }
[15:32:45.394]                       }
[15:32:45.394]                       invisible(muffled)
[15:32:45.394]                     }
[15:32:45.394]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.394]                   }
[15:32:45.394]                 }
[15:32:45.394]             }
[15:32:45.394]         }))
[15:32:45.394]     }, error = function(ex) {
[15:32:45.394]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:45.394]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.394]                 ...future.rng), started = ...future.startTime, 
[15:32:45.394]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:45.394]             version = "1.8"), class = "FutureResult")
[15:32:45.394]     }, finally = {
[15:32:45.394]         if (!identical(...future.workdir, getwd())) 
[15:32:45.394]             setwd(...future.workdir)
[15:32:45.394]         {
[15:32:45.394]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:45.394]                 ...future.oldOptions$nwarnings <- NULL
[15:32:45.394]             }
[15:32:45.394]             base::options(...future.oldOptions)
[15:32:45.394]             if (.Platform$OS.type == "windows") {
[15:32:45.394]                 old_names <- names(...future.oldEnvVars)
[15:32:45.394]                 envs <- base::Sys.getenv()
[15:32:45.394]                 names <- names(envs)
[15:32:45.394]                 common <- intersect(names, old_names)
[15:32:45.394]                 added <- setdiff(names, old_names)
[15:32:45.394]                 removed <- setdiff(old_names, names)
[15:32:45.394]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:45.394]                   envs[common]]
[15:32:45.394]                 NAMES <- toupper(changed)
[15:32:45.394]                 args <- list()
[15:32:45.394]                 for (kk in seq_along(NAMES)) {
[15:32:45.394]                   name <- changed[[kk]]
[15:32:45.394]                   NAME <- NAMES[[kk]]
[15:32:45.394]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.394]                     next
[15:32:45.394]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.394]                 }
[15:32:45.394]                 NAMES <- toupper(added)
[15:32:45.394]                 for (kk in seq_along(NAMES)) {
[15:32:45.394]                   name <- added[[kk]]
[15:32:45.394]                   NAME <- NAMES[[kk]]
[15:32:45.394]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.394]                     next
[15:32:45.394]                   args[[name]] <- ""
[15:32:45.394]                 }
[15:32:45.394]                 NAMES <- toupper(removed)
[15:32:45.394]                 for (kk in seq_along(NAMES)) {
[15:32:45.394]                   name <- removed[[kk]]
[15:32:45.394]                   NAME <- NAMES[[kk]]
[15:32:45.394]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.394]                     next
[15:32:45.394]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.394]                 }
[15:32:45.394]                 if (length(args) > 0) 
[15:32:45.394]                   base::do.call(base::Sys.setenv, args = args)
[15:32:45.394]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:45.394]             }
[15:32:45.394]             else {
[15:32:45.394]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:45.394]             }
[15:32:45.394]             {
[15:32:45.394]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:45.394]                   0L) {
[15:32:45.394]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:45.394]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:45.394]                   base::options(opts)
[15:32:45.394]                 }
[15:32:45.394]                 {
[15:32:45.394]                   {
[15:32:45.394]                     NULL
[15:32:45.394]                     RNGkind("Mersenne-Twister")
[15:32:45.394]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:45.394]                       inherits = FALSE)
[15:32:45.394]                   }
[15:32:45.394]                   options(future.plan = NULL)
[15:32:45.394]                   if (is.na(NA_character_)) 
[15:32:45.394]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.394]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:45.394]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:45.394]                     .init = FALSE)
[15:32:45.394]                 }
[15:32:45.394]             }
[15:32:45.394]         }
[15:32:45.394]     })
[15:32:45.394]     if (TRUE) {
[15:32:45.394]         base::sink(type = "output", split = FALSE)
[15:32:45.394]         if (TRUE) {
[15:32:45.394]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:45.394]         }
[15:32:45.394]         else {
[15:32:45.394]             ...future.result["stdout"] <- base::list(NULL)
[15:32:45.394]         }
[15:32:45.394]         base::close(...future.stdout)
[15:32:45.394]         ...future.stdout <- NULL
[15:32:45.394]     }
[15:32:45.394]     ...future.result$conditions <- ...future.conditions
[15:32:45.394]     ...future.result$finished <- base::Sys.time()
[15:32:45.394]     ...future.result
[15:32:45.394] }
[15:32:45.401] assign_globals() ...
[15:32:45.401] List of 5
[15:32:45.401]  $ ...future.FUN            :function (x, na.rm = TRUE)  
[15:32:45.401]  $ future.call.arguments    : list()
[15:32:45.401]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.401]  $ ...future.elements_ii    :List of 7
[15:32:45.401]   ..$ : int [1:3] 1 2 3
[15:32:45.401]   ..$ : int [1:4] 1 2 3 4
[15:32:45.401]   ..$ : int [1:5] 1 2 3 4 5
[15:32:45.401]   ..$ : int [1:6] 1 2 3 4 5 6
[15:32:45.401]   ..$ : int [1:7] 1 2 3 4 5 6 7
[15:32:45.401]   ..$ : int [1:8] 1 2 3 4 5 6 7 8
[15:32:45.401]   ..$ : int [1:9] 1 2 3 4 5 6 7 8 9
[15:32:45.401]  $ ...future.seeds_ii       : NULL
[15:32:45.401]  $ ...future.globals.maxSize: NULL
[15:32:45.401]  - attr(*, "where")=List of 5
[15:32:45.401]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:45.401]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:45.401]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:45.401]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:45.401]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:45.401]  - attr(*, "resolved")= logi FALSE
[15:32:45.401]  - attr(*, "total_size")= num 46960
[15:32:45.401]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.401]  - attr(*, "already-done")= logi TRUE
[15:32:45.418] - copied '...future.FUN' to environment
[15:32:45.419] - copied 'future.call.arguments' to environment
[15:32:45.419] - copied '...future.elements_ii' to environment
[15:32:45.420] - copied '...future.seeds_ii' to environment
[15:32:45.420] - copied '...future.globals.maxSize' to environment
[15:32:45.420] assign_globals() ... done
[15:32:45.421] plan(): Setting new future strategy stack:
[15:32:45.422] List of future strategies:
[15:32:45.422] 1. sequential:
[15:32:45.422]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.422]    - tweaked: FALSE
[15:32:45.422]    - call: NULL
[15:32:45.423] plan(): nbrOfWorkers() = 1
[15:32:45.425] plan(): Setting new future strategy stack:
[15:32:45.426] List of future strategies:
[15:32:45.426] 1. sequential:
[15:32:45.426]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.426]    - tweaked: FALSE
[15:32:45.426]    - call: plan(strategy)
[15:32:45.427] plan(): nbrOfWorkers() = 1
[15:32:45.427] SequentialFuture started (and completed)
[15:32:45.428] - Launch lazy future ... done
[15:32:45.428] run() for 'SequentialFuture' ... done
[15:32:45.429] Created future:
[15:32:45.429] SequentialFuture:
[15:32:45.429] Label: 'future_sapply-1'
[15:32:45.429] Expression:
[15:32:45.429] {
[15:32:45.429]     do.call(function(...) {
[15:32:45.429]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.429]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.429]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.429]             on.exit(options(oopts), add = TRUE)
[15:32:45.429]         }
[15:32:45.429]         {
[15:32:45.429]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.429]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.429]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.429]             })
[15:32:45.429]         }
[15:32:45.429]     }, args = future.call.arguments)
[15:32:45.429] }
[15:32:45.429] Lazy evaluation: FALSE
[15:32:45.429] Asynchronous evaluation: FALSE
[15:32:45.429] Local evaluation: TRUE
[15:32:45.429] Environment: R_GlobalEnv
[15:32:45.429] Capture standard output: TRUE
[15:32:45.429] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:45.429] Globals: 5 objects totaling 46.39 KiB (function '...future.FUN' of 45.86 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 544 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:45.429] Packages: 1 packages ('stats')
[15:32:45.429] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:45.429] Resolved: TRUE
[15:32:45.429] Value: 672 bytes of class 'list'
[15:32:45.429] Early signaling: FALSE
[15:32:45.429] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:45.429] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.431] Chunk #1 of 1 ... DONE
[15:32:45.432] Launching 1 futures (chunks) ... DONE
[15:32:45.432] Resolving 1 futures (chunks) ...
[15:32:45.432] resolve() on list ...
[15:32:45.433]  recursive: 0
[15:32:45.433]  length: 1
[15:32:45.433] 
[15:32:45.433] resolved() for 'SequentialFuture' ...
[15:32:45.434] - state: 'finished'
[15:32:45.434] - run: TRUE
[15:32:45.434] - result: 'FutureResult'
[15:32:45.435] resolved() for 'SequentialFuture' ... done
[15:32:45.435] Future #1
[15:32:45.436] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:45.436] - nx: 1
[15:32:45.436] - relay: TRUE
[15:32:45.436] - stdout: TRUE
[15:32:45.437] - signal: TRUE
[15:32:45.437] - resignal: FALSE
[15:32:45.437] - force: TRUE
[15:32:45.438] - relayed: [n=1] FALSE
[15:32:45.438] - queued futures: [n=1] FALSE
[15:32:45.438]  - until=1
[15:32:45.438]  - relaying element #1
[15:32:45.439] - relayed: [n=1] TRUE
[15:32:45.439] - queued futures: [n=1] TRUE
[15:32:45.440] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:45.440]  length: 0 (resolved future 1)
[15:32:45.440] Relaying remaining futures
[15:32:45.441] signalConditionsASAP(NULL, pos=0) ...
[15:32:45.441] - nx: 1
[15:32:45.441] - relay: TRUE
[15:32:45.441] - stdout: TRUE
[15:32:45.442] - signal: TRUE
[15:32:45.442] - resignal: FALSE
[15:32:45.442] - force: TRUE
[15:32:45.442] - relayed: [n=1] TRUE
[15:32:45.443] - queued futures: [n=1] TRUE
 - flush all
[15:32:45.443] - relayed: [n=1] TRUE
[15:32:45.444] - queued futures: [n=1] TRUE
[15:32:45.444] signalConditionsASAP(NULL, pos=0) ... done
[15:32:45.444] resolve() on list ... DONE
[15:32:45.445]  - Number of value chunks collected: 1
[15:32:45.445] Resolving 1 futures (chunks) ... DONE
[15:32:45.445] Reducing values from 1 chunks ...
[15:32:45.445]  - Number of values collected after concatenation: 7
[15:32:45.446]  - Number of values expected: 7
[15:32:45.446] Reducing values from 1 chunks ... DONE
[15:32:45.446] future_lapply() ... DONE
[15:32:45.447] future_lapply() ...
[15:32:45.450] Number of chunks: 1
[15:32:45.450] getGlobalsAndPackagesXApply() ...
[15:32:45.450]  - future.globals: TRUE
[15:32:45.450] getGlobalsAndPackages() ...
[15:32:45.451] Searching for globals...
[15:32:45.463] - globals found: [31] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'is.na', 'any', '[', '!', 'return', 'rep.int', 'sort', '/', 'floor', '(', '+', 'c', '-', '*', 'ceiling'
[15:32:45.464] Searching for globals ... DONE
[15:32:45.464] Resolving globals: FALSE
[15:32:45.465] The total size of the 7 globals is 137.93 KiB (141240 bytes)
[15:32:45.466] The total size of the 7 globals exported for future expression ('FUN()') is 137.93 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'x_FUN' (45.86 KiB of class 'function'), 'stop_if_not' (44.12 KiB of class 'function') and 'stopf' (26.43 KiB of class 'function')
[15:32:45.466] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:45.466] - packages: [2] 'stats', 'future.apply'
[15:32:45.467] getGlobalsAndPackages() ... DONE
[15:32:45.467]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:45.467]  - needed namespaces: [n=2] 'stats', 'future.apply'
[15:32:45.467] Finding globals ... DONE
[15:32:45.467]  - use_args: TRUE
[15:32:45.467]  - Getting '...' globals ...
[15:32:45.468] resolve() on list ...
[15:32:45.468]  recursive: 0
[15:32:45.468]  length: 1
[15:32:45.468]  elements: '...'
[15:32:45.469]  length: 0 (resolved future 1)
[15:32:45.469] resolve() on list ... DONE
[15:32:45.469]    - '...' content: [n=0] 
[15:32:45.469] List of 1
[15:32:45.469]  $ ...: list()
[15:32:45.469]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.469]  - attr(*, "where")=List of 1
[15:32:45.469]   ..$ ...:<environment: 0x0000022d3c9ba8f0> 
[15:32:45.469]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.469]  - attr(*, "resolved")= logi TRUE
[15:32:45.469]  - attr(*, "total_size")= num NA
[15:32:45.472]  - Getting '...' globals ... DONE
[15:32:45.473] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:45.473] List of 8
[15:32:45.473]  $ ...future.FUN:function (x, ...)  
[15:32:45.473]  $ x_FUN        :function (x, na.rm = TRUE)  
[15:32:45.473]  $ times        : int 5
[15:32:45.473]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.473]  $ stop_if_not  :function (...)  
[15:32:45.473]  $ dim          : NULL
[15:32:45.473]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:45.473]  $ ...          : list()
[15:32:45.473]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.473]  - attr(*, "where")=List of 8
[15:32:45.473]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:45.473]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:45.473]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:45.473]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:45.473]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:45.473]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:45.473]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:45.473]   ..$ ...          :<environment: 0x0000022d3c9ba8f0> 
[15:32:45.473]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.473]  - attr(*, "resolved")= logi FALSE
[15:32:45.473]  - attr(*, "total_size")= num 141240
[15:32:45.482] Packages to be attached in all futures: [n=2] 'stats', 'future.apply'
[15:32:45.482] getGlobalsAndPackagesXApply() ... DONE
[15:32:45.483] Number of futures (= number of chunks): 1
[15:32:45.483] Launching 1 futures (chunks) ...
[15:32:45.483] Chunk #1 of 1 ...
[15:32:45.484]  - Finding globals in 'X' for chunk #1 ...
[15:32:45.484] getGlobalsAndPackages() ...
[15:32:45.484] Searching for globals...
[15:32:45.484] 
[15:32:45.485] Searching for globals ... DONE
[15:32:45.485] - globals: [0] <none>
[15:32:45.485] getGlobalsAndPackages() ... DONE
[15:32:45.485]    + additional globals found: [n=0] 
[15:32:45.485]    + additional namespaces needed: [n=0] 
[15:32:45.486]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:45.486]  - seeds: <none>
[15:32:45.486]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.486] getGlobalsAndPackages() ...
[15:32:45.487] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.487] Resolving globals: FALSE
[15:32:45.487] Tweak future expression to call with '...' arguments ...
[15:32:45.487] {
[15:32:45.487]     do.call(function(...) {
[15:32:45.487]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.487]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.487]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.487]             on.exit(options(oopts), add = TRUE)
[15:32:45.487]         }
[15:32:45.487]         {
[15:32:45.487]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.487]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.487]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.487]             })
[15:32:45.487]         }
[15:32:45.487]     }, args = future.call.arguments)
[15:32:45.487] }
[15:32:45.488] Tweak future expression to call with '...' arguments ... DONE
[15:32:45.489] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.489] - packages: [2] 'stats', 'future.apply'
[15:32:45.489] getGlobalsAndPackages() ... DONE
[15:32:45.489] run() for 'Future' ...
[15:32:45.490] - state: 'created'
[15:32:45.490] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:45.490] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.491] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:45.491]   - Field: 'label'
[15:32:45.491]   - Field: 'local'
[15:32:45.491]   - Field: 'owner'
[15:32:45.492]   - Field: 'envir'
[15:32:45.492]   - Field: 'packages'
[15:32:45.492]   - Field: 'gc'
[15:32:45.492]   - Field: 'conditions'
[15:32:45.493]   - Field: 'expr'
[15:32:45.493]   - Field: 'uuid'
[15:32:45.493]   - Field: 'seed'
[15:32:45.494]   - Field: 'version'
[15:32:45.494]   - Field: 'result'
[15:32:45.494]   - Field: 'asynchronous'
[15:32:45.495]   - Field: 'calls'
[15:32:45.495]   - Field: 'globals'
[15:32:45.495]   - Field: 'stdout'
[15:32:45.495]   - Field: 'earlySignal'
[15:32:45.496]   - Field: 'lazy'
[15:32:45.496]   - Field: 'state'
[15:32:45.496] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:45.497] - Launch lazy future ...
[15:32:45.497] Packages needed by the future expression (n = 2): 'stats', 'future.apply'
[15:32:45.497] Packages needed by future strategies (n = 0): <none>
[15:32:45.499] {
[15:32:45.499]     {
[15:32:45.499]         {
[15:32:45.499]             ...future.startTime <- base::Sys.time()
[15:32:45.499]             {
[15:32:45.499]                 {
[15:32:45.499]                   {
[15:32:45.499]                     {
[15:32:45.499]                       base::local({
[15:32:45.499]                         has_future <- base::requireNamespace("future", 
[15:32:45.499]                           quietly = TRUE)
[15:32:45.499]                         if (has_future) {
[15:32:45.499]                           ns <- base::getNamespace("future")
[15:32:45.499]                           version <- ns[[".package"]][["version"]]
[15:32:45.499]                           if (is.null(version)) 
[15:32:45.499]                             version <- utils::packageVersion("future")
[15:32:45.499]                         }
[15:32:45.499]                         else {
[15:32:45.499]                           version <- NULL
[15:32:45.499]                         }
[15:32:45.499]                         if (!has_future || version < "1.8.0") {
[15:32:45.499]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:45.499]                             "", base::R.version$version.string), 
[15:32:45.499]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:45.499]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:45.499]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:45.499]                               "release", "version")], collapse = " "), 
[15:32:45.499]                             hostname = base::Sys.info()[["nodename"]])
[15:32:45.499]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:45.499]                             info)
[15:32:45.499]                           info <- base::paste(info, collapse = "; ")
[15:32:45.499]                           if (!has_future) {
[15:32:45.499]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:45.499]                               info)
[15:32:45.499]                           }
[15:32:45.499]                           else {
[15:32:45.499]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:45.499]                               info, version)
[15:32:45.499]                           }
[15:32:45.499]                           base::stop(msg)
[15:32:45.499]                         }
[15:32:45.499]                       })
[15:32:45.499]                     }
[15:32:45.499]                     base::local({
[15:32:45.499]                       for (pkg in c("stats", "future.apply")) {
[15:32:45.499]                         base::loadNamespace(pkg)
[15:32:45.499]                         base::library(pkg, character.only = TRUE)
[15:32:45.499]                       }
[15:32:45.499]                     })
[15:32:45.499]                   }
[15:32:45.499]                   ...future.strategy.old <- future::plan("list")
[15:32:45.499]                   options(future.plan = NULL)
[15:32:45.499]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.499]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:45.499]                 }
[15:32:45.499]                 ...future.workdir <- getwd()
[15:32:45.499]             }
[15:32:45.499]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:45.499]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:45.499]         }
[15:32:45.499]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:45.499]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:45.499]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:45.499]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:45.499]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:45.499]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:45.499]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:45.499]             base::names(...future.oldOptions))
[15:32:45.499]     }
[15:32:45.499]     if (FALSE) {
[15:32:45.499]     }
[15:32:45.499]     else {
[15:32:45.499]         if (TRUE) {
[15:32:45.499]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:45.499]                 open = "w")
[15:32:45.499]         }
[15:32:45.499]         else {
[15:32:45.499]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:45.499]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:45.499]         }
[15:32:45.499]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:45.499]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:45.499]             base::sink(type = "output", split = FALSE)
[15:32:45.499]             base::close(...future.stdout)
[15:32:45.499]         }, add = TRUE)
[15:32:45.499]     }
[15:32:45.499]     ...future.frame <- base::sys.nframe()
[15:32:45.499]     ...future.conditions <- base::list()
[15:32:45.499]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:45.499]     if (FALSE) {
[15:32:45.499]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:45.499]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:45.499]     }
[15:32:45.499]     ...future.result <- base::tryCatch({
[15:32:45.499]         base::withCallingHandlers({
[15:32:45.499]             ...future.value <- base::withVisible(base::local({
[15:32:45.499]                 do.call(function(...) {
[15:32:45.499]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.499]                   if (!identical(...future.globals.maxSize.org, 
[15:32:45.499]                     ...future.globals.maxSize)) {
[15:32:45.499]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.499]                     on.exit(options(oopts), add = TRUE)
[15:32:45.499]                   }
[15:32:45.499]                   {
[15:32:45.499]                     lapply(seq_along(...future.elements_ii), 
[15:32:45.499]                       FUN = function(jj) {
[15:32:45.499]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.499]                         ...future.FUN(...future.X_jj, ...)
[15:32:45.499]                       })
[15:32:45.499]                   }
[15:32:45.499]                 }, args = future.call.arguments)
[15:32:45.499]             }))
[15:32:45.499]             future::FutureResult(value = ...future.value$value, 
[15:32:45.499]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.499]                   ...future.rng), globalenv = if (FALSE) 
[15:32:45.499]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:45.499]                     ...future.globalenv.names))
[15:32:45.499]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:45.499]         }, condition = base::local({
[15:32:45.499]             c <- base::c
[15:32:45.499]             inherits <- base::inherits
[15:32:45.499]             invokeRestart <- base::invokeRestart
[15:32:45.499]             length <- base::length
[15:32:45.499]             list <- base::list
[15:32:45.499]             seq.int <- base::seq.int
[15:32:45.499]             signalCondition <- base::signalCondition
[15:32:45.499]             sys.calls <- base::sys.calls
[15:32:45.499]             `[[` <- base::`[[`
[15:32:45.499]             `+` <- base::`+`
[15:32:45.499]             `<<-` <- base::`<<-`
[15:32:45.499]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:45.499]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:45.499]                   3L)]
[15:32:45.499]             }
[15:32:45.499]             function(cond) {
[15:32:45.499]                 is_error <- inherits(cond, "error")
[15:32:45.499]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:45.499]                   NULL)
[15:32:45.499]                 if (is_error) {
[15:32:45.499]                   sessionInformation <- function() {
[15:32:45.499]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:45.499]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:45.499]                       search = base::search(), system = base::Sys.info())
[15:32:45.499]                   }
[15:32:45.499]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.499]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:45.499]                     cond$call), session = sessionInformation(), 
[15:32:45.499]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:45.499]                   signalCondition(cond)
[15:32:45.499]                 }
[15:32:45.499]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:45.499]                 "immediateCondition"))) {
[15:32:45.499]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:45.499]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.499]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:45.499]                   if (TRUE && !signal) {
[15:32:45.499]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.499]                     {
[15:32:45.499]                       inherits <- base::inherits
[15:32:45.499]                       invokeRestart <- base::invokeRestart
[15:32:45.499]                       is.null <- base::is.null
[15:32:45.499]                       muffled <- FALSE
[15:32:45.499]                       if (inherits(cond, "message")) {
[15:32:45.499]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.499]                         if (muffled) 
[15:32:45.499]                           invokeRestart("muffleMessage")
[15:32:45.499]                       }
[15:32:45.499]                       else if (inherits(cond, "warning")) {
[15:32:45.499]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.499]                         if (muffled) 
[15:32:45.499]                           invokeRestart("muffleWarning")
[15:32:45.499]                       }
[15:32:45.499]                       else if (inherits(cond, "condition")) {
[15:32:45.499]                         if (!is.null(pattern)) {
[15:32:45.499]                           computeRestarts <- base::computeRestarts
[15:32:45.499]                           grepl <- base::grepl
[15:32:45.499]                           restarts <- computeRestarts(cond)
[15:32:45.499]                           for (restart in restarts) {
[15:32:45.499]                             name <- restart$name
[15:32:45.499]                             if (is.null(name)) 
[15:32:45.499]                               next
[15:32:45.499]                             if (!grepl(pattern, name)) 
[15:32:45.499]                               next
[15:32:45.499]                             invokeRestart(restart)
[15:32:45.499]                             muffled <- TRUE
[15:32:45.499]                             break
[15:32:45.499]                           }
[15:32:45.499]                         }
[15:32:45.499]                       }
[15:32:45.499]                       invisible(muffled)
[15:32:45.499]                     }
[15:32:45.499]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.499]                   }
[15:32:45.499]                 }
[15:32:45.499]                 else {
[15:32:45.499]                   if (TRUE) {
[15:32:45.499]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.499]                     {
[15:32:45.499]                       inherits <- base::inherits
[15:32:45.499]                       invokeRestart <- base::invokeRestart
[15:32:45.499]                       is.null <- base::is.null
[15:32:45.499]                       muffled <- FALSE
[15:32:45.499]                       if (inherits(cond, "message")) {
[15:32:45.499]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.499]                         if (muffled) 
[15:32:45.499]                           invokeRestart("muffleMessage")
[15:32:45.499]                       }
[15:32:45.499]                       else if (inherits(cond, "warning")) {
[15:32:45.499]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.499]                         if (muffled) 
[15:32:45.499]                           invokeRestart("muffleWarning")
[15:32:45.499]                       }
[15:32:45.499]                       else if (inherits(cond, "condition")) {
[15:32:45.499]                         if (!is.null(pattern)) {
[15:32:45.499]                           computeRestarts <- base::computeRestarts
[15:32:45.499]                           grepl <- base::grepl
[15:32:45.499]                           restarts <- computeRestarts(cond)
[15:32:45.499]                           for (restart in restarts) {
[15:32:45.499]                             name <- restart$name
[15:32:45.499]                             if (is.null(name)) 
[15:32:45.499]                               next
[15:32:45.499]                             if (!grepl(pattern, name)) 
[15:32:45.499]                               next
[15:32:45.499]                             invokeRestart(restart)
[15:32:45.499]                             muffled <- TRUE
[15:32:45.499]                             break
[15:32:45.499]                           }
[15:32:45.499]                         }
[15:32:45.499]                       }
[15:32:45.499]                       invisible(muffled)
[15:32:45.499]                     }
[15:32:45.499]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.499]                   }
[15:32:45.499]                 }
[15:32:45.499]             }
[15:32:45.499]         }))
[15:32:45.499]     }, error = function(ex) {
[15:32:45.499]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:45.499]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.499]                 ...future.rng), started = ...future.startTime, 
[15:32:45.499]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:45.499]             version = "1.8"), class = "FutureResult")
[15:32:45.499]     }, finally = {
[15:32:45.499]         if (!identical(...future.workdir, getwd())) 
[15:32:45.499]             setwd(...future.workdir)
[15:32:45.499]         {
[15:32:45.499]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:45.499]                 ...future.oldOptions$nwarnings <- NULL
[15:32:45.499]             }
[15:32:45.499]             base::options(...future.oldOptions)
[15:32:45.499]             if (.Platform$OS.type == "windows") {
[15:32:45.499]                 old_names <- names(...future.oldEnvVars)
[15:32:45.499]                 envs <- base::Sys.getenv()
[15:32:45.499]                 names <- names(envs)
[15:32:45.499]                 common <- intersect(names, old_names)
[15:32:45.499]                 added <- setdiff(names, old_names)
[15:32:45.499]                 removed <- setdiff(old_names, names)
[15:32:45.499]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:45.499]                   envs[common]]
[15:32:45.499]                 NAMES <- toupper(changed)
[15:32:45.499]                 args <- list()
[15:32:45.499]                 for (kk in seq_along(NAMES)) {
[15:32:45.499]                   name <- changed[[kk]]
[15:32:45.499]                   NAME <- NAMES[[kk]]
[15:32:45.499]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.499]                     next
[15:32:45.499]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.499]                 }
[15:32:45.499]                 NAMES <- toupper(added)
[15:32:45.499]                 for (kk in seq_along(NAMES)) {
[15:32:45.499]                   name <- added[[kk]]
[15:32:45.499]                   NAME <- NAMES[[kk]]
[15:32:45.499]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.499]                     next
[15:32:45.499]                   args[[name]] <- ""
[15:32:45.499]                 }
[15:32:45.499]                 NAMES <- toupper(removed)
[15:32:45.499]                 for (kk in seq_along(NAMES)) {
[15:32:45.499]                   name <- removed[[kk]]
[15:32:45.499]                   NAME <- NAMES[[kk]]
[15:32:45.499]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.499]                     next
[15:32:45.499]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.499]                 }
[15:32:45.499]                 if (length(args) > 0) 
[15:32:45.499]                   base::do.call(base::Sys.setenv, args = args)
[15:32:45.499]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:45.499]             }
[15:32:45.499]             else {
[15:32:45.499]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:45.499]             }
[15:32:45.499]             {
[15:32:45.499]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:45.499]                   0L) {
[15:32:45.499]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:45.499]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:45.499]                   base::options(opts)
[15:32:45.499]                 }
[15:32:45.499]                 {
[15:32:45.499]                   {
[15:32:45.499]                     NULL
[15:32:45.499]                     RNGkind("Mersenne-Twister")
[15:32:45.499]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:45.499]                       inherits = FALSE)
[15:32:45.499]                   }
[15:32:45.499]                   options(future.plan = NULL)
[15:32:45.499]                   if (is.na(NA_character_)) 
[15:32:45.499]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.499]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:45.499]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:45.499]                     .init = FALSE)
[15:32:45.499]                 }
[15:32:45.499]             }
[15:32:45.499]         }
[15:32:45.499]     })
[15:32:45.499]     if (TRUE) {
[15:32:45.499]         base::sink(type = "output", split = FALSE)
[15:32:45.499]         if (TRUE) {
[15:32:45.499]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:45.499]         }
[15:32:45.499]         else {
[15:32:45.499]             ...future.result["stdout"] <- base::list(NULL)
[15:32:45.499]         }
[15:32:45.499]         base::close(...future.stdout)
[15:32:45.499]         ...future.stdout <- NULL
[15:32:45.499]     }
[15:32:45.499]     ...future.result$conditions <- ...future.conditions
[15:32:45.499]     ...future.result$finished <- base::Sys.time()
[15:32:45.499]     ...future.result
[15:32:45.499] }
[15:32:45.505] assign_globals() ...
[15:32:45.505] List of 11
[15:32:45.505]  $ ...future.FUN            :function (x, ...)  
[15:32:45.505]  $ x_FUN                    :function (x, na.rm = TRUE)  
[15:32:45.505]  $ times                    : int 5
[15:32:45.505]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.505]  $ stop_if_not              :function (...)  
[15:32:45.505]  $ dim                      : NULL
[15:32:45.505]  $ valid_types              : chr [1:3] "logical" "integer" "double"
[15:32:45.505]  $ future.call.arguments    : list()
[15:32:45.505]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.505]  $ ...future.elements_ii    :List of 7
[15:32:45.505]   ..$ : int [1:3] 1 2 3
[15:32:45.505]   ..$ : int [1:4] 1 2 3 4
[15:32:45.505]   ..$ : int [1:5] 1 2 3 4 5
[15:32:45.505]   ..$ : int [1:6] 1 2 3 4 5 6
[15:32:45.505]   ..$ : int [1:7] 1 2 3 4 5 6 7
[15:32:45.505]   ..$ : int [1:8] 1 2 3 4 5 6 7 8
[15:32:45.505]   ..$ : int [1:9] 1 2 3 4 5 6 7 8 9
[15:32:45.505]  $ ...future.seeds_ii       : NULL
[15:32:45.505]  $ ...future.globals.maxSize: NULL
[15:32:45.505]  - attr(*, "where")=List of 11
[15:32:45.505]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:45.505]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:45.505]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:45.505]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:45.505]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:45.505]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:45.505]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:45.505]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:45.505]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:45.505]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:45.505]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:45.505]  - attr(*, "resolved")= logi FALSE
[15:32:45.505]  - attr(*, "total_size")= num 141240
[15:32:45.505]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.505]  - attr(*, "already-done")= logi TRUE
[15:32:45.526] - copied '...future.FUN' to environment
[15:32:45.527] - copied 'x_FUN' to environment
[15:32:45.527] - copied 'times' to environment
[15:32:45.527] - copied 'stopf' to environment
[15:32:45.528] - copied 'stop_if_not' to environment
[15:32:45.528] - copied 'dim' to environment
[15:32:45.528] - copied 'valid_types' to environment
[15:32:45.529] - copied 'future.call.arguments' to environment
[15:32:45.529] - copied '...future.elements_ii' to environment
[15:32:45.529] - copied '...future.seeds_ii' to environment
[15:32:45.530] - copied '...future.globals.maxSize' to environment
[15:32:45.530] assign_globals() ... done
[15:32:45.531] plan(): Setting new future strategy stack:
[15:32:45.532] List of future strategies:
[15:32:45.532] 1. sequential:
[15:32:45.532]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.532]    - tweaked: FALSE
[15:32:45.532]    - call: NULL
[15:32:45.533] plan(): nbrOfWorkers() = 1
[15:32:45.535] plan(): Setting new future strategy stack:
[15:32:45.535] List of future strategies:
[15:32:45.535] 1. sequential:
[15:32:45.535]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.535]    - tweaked: FALSE
[15:32:45.535]    - call: plan(strategy)
[15:32:45.536] plan(): nbrOfWorkers() = 1
[15:32:45.536] SequentialFuture started (and completed)
[15:32:45.537] - Launch lazy future ... done
[15:32:45.537] run() for 'SequentialFuture' ... done
[15:32:45.537] Created future:
[15:32:45.538] SequentialFuture:
[15:32:45.538] Label: 'future_vapply-1'
[15:32:45.538] Expression:
[15:32:45.538] {
[15:32:45.538]     do.call(function(...) {
[15:32:45.538]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.538]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.538]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.538]             on.exit(options(oopts), add = TRUE)
[15:32:45.538]         }
[15:32:45.538]         {
[15:32:45.538]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.538]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.538]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.538]             })
[15:32:45.538]         }
[15:32:45.538]     }, args = future.call.arguments)
[15:32:45.538] }
[15:32:45.538] Lazy evaluation: FALSE
[15:32:45.538] Asynchronous evaluation: FALSE
[15:32:45.538] Local evaluation: TRUE
[15:32:45.538] Environment: R_GlobalEnv
[15:32:45.538] Capture standard output: TRUE
[15:32:45.538] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:45.538] Globals: 11 objects totaling 138.46 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 45.86 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:45.538] Packages: 2 packages ('stats', 'future.apply')
[15:32:45.538] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:45.538] Resolved: TRUE
[15:32:45.538] Value: 672 bytes of class 'list'
[15:32:45.538] Early signaling: FALSE
[15:32:45.538] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:45.538] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.540] Chunk #1 of 1 ... DONE
[15:32:45.540] Launching 1 futures (chunks) ... DONE
[15:32:45.541] Resolving 1 futures (chunks) ...
[15:32:45.541] resolve() on list ...
[15:32:45.541]  recursive: 0
[15:32:45.541]  length: 1
[15:32:45.542] 
[15:32:45.542] resolved() for 'SequentialFuture' ...
[15:32:45.542] - state: 'finished'
[15:32:45.543] - run: TRUE
[15:32:45.543] - result: 'FutureResult'
[15:32:45.543] resolved() for 'SequentialFuture' ... done
[15:32:45.544] Future #1
[15:32:45.544] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:45.544] - nx: 1
[15:32:45.545] - relay: TRUE
[15:32:45.545] - stdout: TRUE
[15:32:45.545] - signal: TRUE
[15:32:45.545] - resignal: FALSE
[15:32:45.546] - force: TRUE
[15:32:45.546] - relayed: [n=1] FALSE
[15:32:45.546] - queued futures: [n=1] FALSE
[15:32:45.546]  - until=1
[15:32:45.547]  - relaying element #1
[15:32:45.547] - relayed: [n=1] TRUE
[15:32:45.547] - queued futures: [n=1] TRUE
[15:32:45.547] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:45.548]  length: 0 (resolved future 1)
[15:32:45.548] Relaying remaining futures
[15:32:45.548] signalConditionsASAP(NULL, pos=0) ...
[15:32:45.549] - nx: 1
[15:32:45.549] - relay: TRUE
[15:32:45.549] - stdout: TRUE
[15:32:45.549] - signal: TRUE
[15:32:45.550] - resignal: FALSE
[15:32:45.550] - force: TRUE
[15:32:45.550] - relayed: [n=1] TRUE
[15:32:45.550] - queued futures: [n=1] TRUE
 - flush all
[15:32:45.551] - relayed: [n=1] TRUE
[15:32:45.551] - queued futures: [n=1] TRUE
[15:32:45.551] signalConditionsASAP(NULL, pos=0) ... done
[15:32:45.551] resolve() on list ... DONE
[15:32:45.552]  - Number of value chunks collected: 1
[15:32:45.552] Resolving 1 futures (chunks) ... DONE
[15:32:45.552] Reducing values from 1 chunks ...
[15:32:45.553]  - Number of values collected after concatenation: 7
[15:32:45.553]  - Number of values expected: 7
[15:32:45.553] Reducing values from 1 chunks ... DONE
[15:32:45.553] future_lapply() ... DONE
 num [1:5, 1:7] 1 1.5 2 2.5 3 1 1.5 2.5 3.5 4 ...
 - attr(*, "dimnames")=List of 2
  ..$ : chr [1:5] "Min." "1st Qu." "Median" "3rd Qu." ...
  ..$ : NULL
[15:32:45.556] future_lapply() ...
[15:32:45.558] Number of chunks: 1
[15:32:45.558] getGlobalsAndPackagesXApply() ...
[15:32:45.558]  - future.globals: TRUE
[15:32:45.558] getGlobalsAndPackages() ...
[15:32:45.559] Searching for globals...
[15:32:45.561] - globals found: [3] 'FUN', 'outer', 'rep'
[15:32:45.561] Searching for globals ... DONE
[15:32:45.562] Resolving globals: FALSE
[15:32:45.562] The total size of the 1 globals is 4.07 KiB (4168 bytes)
[15:32:45.563] The total size of the 1 globals exported for future expression ('FUN(y = c(2, 4, 6, 8, 10))') is 4.07 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.07 KiB of class 'function')
[15:32:45.563] - globals: [1] 'FUN'
[15:32:45.564] 
[15:32:45.566] getGlobalsAndPackages() ... DONE
[15:32:45.567]  - globals found/used: [n=1] 'FUN'
[15:32:45.567]  - needed namespaces: [n=0] 
[15:32:45.567] Finding globals ... DONE
[15:32:45.568]  - use_args: TRUE
[15:32:45.568]  - Getting '...' globals ...
[15:32:45.569] resolve() on list ...
[15:32:45.569]  recursive: 0
[15:32:45.569]  length: 1
[15:32:45.570]  elements: '...'
[15:32:45.570]  length: 0 (resolved future 1)
[15:32:45.570] resolve() on list ... DONE
[15:32:45.570]    - '...' content: [n=1] 'y'
[15:32:45.571] List of 1
[15:32:45.571]  $ ...:List of 1
[15:32:45.571]   ..$ y: num [1:5] 2 4 6 8 10
[15:32:45.571]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.571]  - attr(*, "where")=List of 1
[15:32:45.571]   ..$ ...:<environment: 0x0000022d3de5b730> 
[15:32:45.571]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.571]  - attr(*, "resolved")= logi TRUE
[15:32:45.571]  - attr(*, "total_size")= num NA
[15:32:45.577]  - Getting '...' globals ... DONE
[15:32:45.577] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:45.578] List of 2
[15:32:45.578]  $ ...future.FUN:function (x, y)  
[15:32:45.578]  $ ...          :List of 1
[15:32:45.578]   ..$ y: num [1:5] 2 4 6 8 10
[15:32:45.578]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.578]  - attr(*, "where")=List of 2
[15:32:45.578]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:45.578]   ..$ ...          :<environment: 0x0000022d3de5b730> 
[15:32:45.578]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.578]  - attr(*, "resolved")= logi FALSE
[15:32:45.578]  - attr(*, "total_size")= num 4264
[15:32:45.583] Packages to be attached in all futures: [n=0] 
[15:32:45.583] getGlobalsAndPackagesXApply() ... DONE
[15:32:45.583] Number of futures (= number of chunks): 1
[15:32:45.584] Launching 1 futures (chunks) ...
[15:32:45.584] Chunk #1 of 1 ...
[15:32:45.584]  - Finding globals in 'X' for chunk #1 ...
[15:32:45.585] getGlobalsAndPackages() ...
[15:32:45.585] Searching for globals...
[15:32:45.585] 
[15:32:45.585] Searching for globals ... DONE
[15:32:45.586] - globals: [0] <none>
[15:32:45.586] getGlobalsAndPackages() ... DONE
[15:32:45.586]    + additional globals found: [n=0] 
[15:32:45.587]    + additional namespaces needed: [n=0] 
[15:32:45.587]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:45.587]  - seeds: <none>
[15:32:45.587]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.587] getGlobalsAndPackages() ...
[15:32:45.588] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.588] Resolving globals: FALSE
[15:32:45.588] Tweak future expression to call with '...' arguments ...
[15:32:45.589] {
[15:32:45.589]     do.call(function(...) {
[15:32:45.589]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.589]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.589]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.589]             on.exit(options(oopts), add = TRUE)
[15:32:45.589]         }
[15:32:45.589]         {
[15:32:45.589]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.589]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.589]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.589]             })
[15:32:45.589]         }
[15:32:45.589]     }, args = future.call.arguments)
[15:32:45.589] }
[15:32:45.589] Tweak future expression to call with '...' arguments ... DONE
[15:32:45.590] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.590] 
[15:32:45.590] getGlobalsAndPackages() ... DONE
[15:32:45.591] run() for 'Future' ...
[15:32:45.591] - state: 'created'
[15:32:45.592] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:45.592] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.592] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:45.593]   - Field: 'label'
[15:32:45.593]   - Field: 'local'
[15:32:45.595]   - Field: 'owner'
[15:32:45.596]   - Field: 'envir'
[15:32:45.596]   - Field: 'packages'
[15:32:45.596]   - Field: 'gc'
[15:32:45.597]   - Field: 'conditions'
[15:32:45.597]   - Field: 'expr'
[15:32:45.597]   - Field: 'uuid'
[15:32:45.598]   - Field: 'seed'
[15:32:45.598]   - Field: 'version'
[15:32:45.598]   - Field: 'result'
[15:32:45.598]   - Field: 'asynchronous'
[15:32:45.599]   - Field: 'calls'
[15:32:45.599]   - Field: 'globals'
[15:32:45.599]   - Field: 'stdout'
[15:32:45.600]   - Field: 'earlySignal'
[15:32:45.600]   - Field: 'lazy'
[15:32:45.600]   - Field: 'state'
[15:32:45.601] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:45.601] - Launch lazy future ...
[15:32:45.601] Packages needed by the future expression (n = 0): <none>
[15:32:45.602] Packages needed by future strategies (n = 0): <none>
[15:32:45.603] {
[15:32:45.603]     {
[15:32:45.603]         {
[15:32:45.603]             ...future.startTime <- base::Sys.time()
[15:32:45.603]             {
[15:32:45.603]                 {
[15:32:45.603]                   {
[15:32:45.603]                     base::local({
[15:32:45.603]                       has_future <- base::requireNamespace("future", 
[15:32:45.603]                         quietly = TRUE)
[15:32:45.603]                       if (has_future) {
[15:32:45.603]                         ns <- base::getNamespace("future")
[15:32:45.603]                         version <- ns[[".package"]][["version"]]
[15:32:45.603]                         if (is.null(version)) 
[15:32:45.603]                           version <- utils::packageVersion("future")
[15:32:45.603]                       }
[15:32:45.603]                       else {
[15:32:45.603]                         version <- NULL
[15:32:45.603]                       }
[15:32:45.603]                       if (!has_future || version < "1.8.0") {
[15:32:45.603]                         info <- base::c(r_version = base::gsub("R version ", 
[15:32:45.603]                           "", base::R.version$version.string), 
[15:32:45.603]                           platform = base::sprintf("%s (%s-bit)", 
[15:32:45.603]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:45.603]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:45.603]                             "release", "version")], collapse = " "), 
[15:32:45.603]                           hostname = base::Sys.info()[["nodename"]])
[15:32:45.603]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:32:45.603]                           info)
[15:32:45.603]                         info <- base::paste(info, collapse = "; ")
[15:32:45.603]                         if (!has_future) {
[15:32:45.603]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:45.603]                             info)
[15:32:45.603]                         }
[15:32:45.603]                         else {
[15:32:45.603]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:45.603]                             info, version)
[15:32:45.603]                         }
[15:32:45.603]                         base::stop(msg)
[15:32:45.603]                       }
[15:32:45.603]                     })
[15:32:45.603]                   }
[15:32:45.603]                   ...future.strategy.old <- future::plan("list")
[15:32:45.603]                   options(future.plan = NULL)
[15:32:45.603]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.603]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:45.603]                 }
[15:32:45.603]                 ...future.workdir <- getwd()
[15:32:45.603]             }
[15:32:45.603]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:45.603]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:45.603]         }
[15:32:45.603]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:45.603]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:45.603]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:45.603]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:45.603]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:45.603]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:45.603]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:45.603]             base::names(...future.oldOptions))
[15:32:45.603]     }
[15:32:45.603]     if (FALSE) {
[15:32:45.603]     }
[15:32:45.603]     else {
[15:32:45.603]         if (TRUE) {
[15:32:45.603]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:45.603]                 open = "w")
[15:32:45.603]         }
[15:32:45.603]         else {
[15:32:45.603]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:45.603]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:45.603]         }
[15:32:45.603]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:45.603]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:45.603]             base::sink(type = "output", split = FALSE)
[15:32:45.603]             base::close(...future.stdout)
[15:32:45.603]         }, add = TRUE)
[15:32:45.603]     }
[15:32:45.603]     ...future.frame <- base::sys.nframe()
[15:32:45.603]     ...future.conditions <- base::list()
[15:32:45.603]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:45.603]     if (FALSE) {
[15:32:45.603]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:45.603]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:45.603]     }
[15:32:45.603]     ...future.result <- base::tryCatch({
[15:32:45.603]         base::withCallingHandlers({
[15:32:45.603]             ...future.value <- base::withVisible(base::local({
[15:32:45.603]                 do.call(function(...) {
[15:32:45.603]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.603]                   if (!identical(...future.globals.maxSize.org, 
[15:32:45.603]                     ...future.globals.maxSize)) {
[15:32:45.603]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.603]                     on.exit(options(oopts), add = TRUE)
[15:32:45.603]                   }
[15:32:45.603]                   {
[15:32:45.603]                     lapply(seq_along(...future.elements_ii), 
[15:32:45.603]                       FUN = function(jj) {
[15:32:45.603]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.603]                         ...future.FUN(...future.X_jj, ...)
[15:32:45.603]                       })
[15:32:45.603]                   }
[15:32:45.603]                 }, args = future.call.arguments)
[15:32:45.603]             }))
[15:32:45.603]             future::FutureResult(value = ...future.value$value, 
[15:32:45.603]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.603]                   ...future.rng), globalenv = if (FALSE) 
[15:32:45.603]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:45.603]                     ...future.globalenv.names))
[15:32:45.603]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:45.603]         }, condition = base::local({
[15:32:45.603]             c <- base::c
[15:32:45.603]             inherits <- base::inherits
[15:32:45.603]             invokeRestart <- base::invokeRestart
[15:32:45.603]             length <- base::length
[15:32:45.603]             list <- base::list
[15:32:45.603]             seq.int <- base::seq.int
[15:32:45.603]             signalCondition <- base::signalCondition
[15:32:45.603]             sys.calls <- base::sys.calls
[15:32:45.603]             `[[` <- base::`[[`
[15:32:45.603]             `+` <- base::`+`
[15:32:45.603]             `<<-` <- base::`<<-`
[15:32:45.603]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:45.603]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:45.603]                   3L)]
[15:32:45.603]             }
[15:32:45.603]             function(cond) {
[15:32:45.603]                 is_error <- inherits(cond, "error")
[15:32:45.603]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:45.603]                   NULL)
[15:32:45.603]                 if (is_error) {
[15:32:45.603]                   sessionInformation <- function() {
[15:32:45.603]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:45.603]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:45.603]                       search = base::search(), system = base::Sys.info())
[15:32:45.603]                   }
[15:32:45.603]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.603]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:45.603]                     cond$call), session = sessionInformation(), 
[15:32:45.603]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:45.603]                   signalCondition(cond)
[15:32:45.603]                 }
[15:32:45.603]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:45.603]                 "immediateCondition"))) {
[15:32:45.603]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:45.603]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.603]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:45.603]                   if (TRUE && !signal) {
[15:32:45.603]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.603]                     {
[15:32:45.603]                       inherits <- base::inherits
[15:32:45.603]                       invokeRestart <- base::invokeRestart
[15:32:45.603]                       is.null <- base::is.null
[15:32:45.603]                       muffled <- FALSE
[15:32:45.603]                       if (inherits(cond, "message")) {
[15:32:45.603]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.603]                         if (muffled) 
[15:32:45.603]                           invokeRestart("muffleMessage")
[15:32:45.603]                       }
[15:32:45.603]                       else if (inherits(cond, "warning")) {
[15:32:45.603]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.603]                         if (muffled) 
[15:32:45.603]                           invokeRestart("muffleWarning")
[15:32:45.603]                       }
[15:32:45.603]                       else if (inherits(cond, "condition")) {
[15:32:45.603]                         if (!is.null(pattern)) {
[15:32:45.603]                           computeRestarts <- base::computeRestarts
[15:32:45.603]                           grepl <- base::grepl
[15:32:45.603]                           restarts <- computeRestarts(cond)
[15:32:45.603]                           for (restart in restarts) {
[15:32:45.603]                             name <- restart$name
[15:32:45.603]                             if (is.null(name)) 
[15:32:45.603]                               next
[15:32:45.603]                             if (!grepl(pattern, name)) 
[15:32:45.603]                               next
[15:32:45.603]                             invokeRestart(restart)
[15:32:45.603]                             muffled <- TRUE
[15:32:45.603]                             break
[15:32:45.603]                           }
[15:32:45.603]                         }
[15:32:45.603]                       }
[15:32:45.603]                       invisible(muffled)
[15:32:45.603]                     }
[15:32:45.603]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.603]                   }
[15:32:45.603]                 }
[15:32:45.603]                 else {
[15:32:45.603]                   if (TRUE) {
[15:32:45.603]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.603]                     {
[15:32:45.603]                       inherits <- base::inherits
[15:32:45.603]                       invokeRestart <- base::invokeRestart
[15:32:45.603]                       is.null <- base::is.null
[15:32:45.603]                       muffled <- FALSE
[15:32:45.603]                       if (inherits(cond, "message")) {
[15:32:45.603]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.603]                         if (muffled) 
[15:32:45.603]                           invokeRestart("muffleMessage")
[15:32:45.603]                       }
[15:32:45.603]                       else if (inherits(cond, "warning")) {
[15:32:45.603]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.603]                         if (muffled) 
[15:32:45.603]                           invokeRestart("muffleWarning")
[15:32:45.603]                       }
[15:32:45.603]                       else if (inherits(cond, "condition")) {
[15:32:45.603]                         if (!is.null(pattern)) {
[15:32:45.603]                           computeRestarts <- base::computeRestarts
[15:32:45.603]                           grepl <- base::grepl
[15:32:45.603]                           restarts <- computeRestarts(cond)
[15:32:45.603]                           for (restart in restarts) {
[15:32:45.603]                             name <- restart$name
[15:32:45.603]                             if (is.null(name)) 
[15:32:45.603]                               next
[15:32:45.603]                             if (!grepl(pattern, name)) 
[15:32:45.603]                               next
[15:32:45.603]                             invokeRestart(restart)
[15:32:45.603]                             muffled <- TRUE
[15:32:45.603]                             break
[15:32:45.603]                           }
[15:32:45.603]                         }
[15:32:45.603]                       }
[15:32:45.603]                       invisible(muffled)
[15:32:45.603]                     }
[15:32:45.603]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.603]                   }
[15:32:45.603]                 }
[15:32:45.603]             }
[15:32:45.603]         }))
[15:32:45.603]     }, error = function(ex) {
[15:32:45.603]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:45.603]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.603]                 ...future.rng), started = ...future.startTime, 
[15:32:45.603]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:45.603]             version = "1.8"), class = "FutureResult")
[15:32:45.603]     }, finally = {
[15:32:45.603]         if (!identical(...future.workdir, getwd())) 
[15:32:45.603]             setwd(...future.workdir)
[15:32:45.603]         {
[15:32:45.603]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:45.603]                 ...future.oldOptions$nwarnings <- NULL
[15:32:45.603]             }
[15:32:45.603]             base::options(...future.oldOptions)
[15:32:45.603]             if (.Platform$OS.type == "windows") {
[15:32:45.603]                 old_names <- names(...future.oldEnvVars)
[15:32:45.603]                 envs <- base::Sys.getenv()
[15:32:45.603]                 names <- names(envs)
[15:32:45.603]                 common <- intersect(names, old_names)
[15:32:45.603]                 added <- setdiff(names, old_names)
[15:32:45.603]                 removed <- setdiff(old_names, names)
[15:32:45.603]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:45.603]                   envs[common]]
[15:32:45.603]                 NAMES <- toupper(changed)
[15:32:45.603]                 args <- list()
[15:32:45.603]                 for (kk in seq_along(NAMES)) {
[15:32:45.603]                   name <- changed[[kk]]
[15:32:45.603]                   NAME <- NAMES[[kk]]
[15:32:45.603]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.603]                     next
[15:32:45.603]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.603]                 }
[15:32:45.603]                 NAMES <- toupper(added)
[15:32:45.603]                 for (kk in seq_along(NAMES)) {
[15:32:45.603]                   name <- added[[kk]]
[15:32:45.603]                   NAME <- NAMES[[kk]]
[15:32:45.603]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.603]                     next
[15:32:45.603]                   args[[name]] <- ""
[15:32:45.603]                 }
[15:32:45.603]                 NAMES <- toupper(removed)
[15:32:45.603]                 for (kk in seq_along(NAMES)) {
[15:32:45.603]                   name <- removed[[kk]]
[15:32:45.603]                   NAME <- NAMES[[kk]]
[15:32:45.603]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.603]                     next
[15:32:45.603]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.603]                 }
[15:32:45.603]                 if (length(args) > 0) 
[15:32:45.603]                   base::do.call(base::Sys.setenv, args = args)
[15:32:45.603]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:45.603]             }
[15:32:45.603]             else {
[15:32:45.603]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:45.603]             }
[15:32:45.603]             {
[15:32:45.603]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:45.603]                   0L) {
[15:32:45.603]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:45.603]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:45.603]                   base::options(opts)
[15:32:45.603]                 }
[15:32:45.603]                 {
[15:32:45.603]                   {
[15:32:45.603]                     NULL
[15:32:45.603]                     RNGkind("Mersenne-Twister")
[15:32:45.603]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:45.603]                       inherits = FALSE)
[15:32:45.603]                   }
[15:32:45.603]                   options(future.plan = NULL)
[15:32:45.603]                   if (is.na(NA_character_)) 
[15:32:45.603]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.603]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:45.603]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:45.603]                     .init = FALSE)
[15:32:45.603]                 }
[15:32:45.603]             }
[15:32:45.603]         }
[15:32:45.603]     })
[15:32:45.603]     if (TRUE) {
[15:32:45.603]         base::sink(type = "output", split = FALSE)
[15:32:45.603]         if (TRUE) {
[15:32:45.603]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:45.603]         }
[15:32:45.603]         else {
[15:32:45.603]             ...future.result["stdout"] <- base::list(NULL)
[15:32:45.603]         }
[15:32:45.603]         base::close(...future.stdout)
[15:32:45.603]         ...future.stdout <- NULL
[15:32:45.603]     }
[15:32:45.603]     ...future.result$conditions <- ...future.conditions
[15:32:45.603]     ...future.result$finished <- base::Sys.time()
[15:32:45.603]     ...future.result
[15:32:45.603] }
[15:32:45.609] assign_globals() ...
[15:32:45.610] List of 5
[15:32:45.610]  $ ...future.FUN            :function (x, y)  
[15:32:45.610]  $ future.call.arguments    :List of 1
[15:32:45.610]   ..$ y: num [1:5] 2 4 6 8 10
[15:32:45.610]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.610]  $ ...future.elements_ii    :List of 4
[15:32:45.610]   ..$ A: num 50
[15:32:45.610]   ..$ B: num 60
[15:32:45.610]   ..$ C: num 70
[15:32:45.610]   ..$ D: num 80
[15:32:45.610]  $ ...future.seeds_ii       : NULL
[15:32:45.610]  $ ...future.globals.maxSize: NULL
[15:32:45.610]  - attr(*, "where")=List of 5
[15:32:45.610]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:45.610]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:45.610]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:45.610]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:45.610]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:45.610]  - attr(*, "resolved")= logi FALSE
[15:32:45.610]  - attr(*, "total_size")= num 4264
[15:32:45.610]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.610]  - attr(*, "already-done")= logi TRUE
[15:32:45.626] - reassign environment for '...future.FUN'
[15:32:45.626] - copied '...future.FUN' to environment
[15:32:45.627] - copied 'future.call.arguments' to environment
[15:32:45.627] - copied '...future.elements_ii' to environment
[15:32:45.627] - copied '...future.seeds_ii' to environment
[15:32:45.627] - copied '...future.globals.maxSize' to environment
[15:32:45.628] assign_globals() ... done
[15:32:45.628] plan(): Setting new future strategy stack:
[15:32:45.629] List of future strategies:
[15:32:45.629] 1. sequential:
[15:32:45.629]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.629]    - tweaked: FALSE
[15:32:45.629]    - call: NULL
[15:32:45.630] plan(): nbrOfWorkers() = 1
[15:32:45.632] plan(): Setting new future strategy stack:
[15:32:45.632] List of future strategies:
[15:32:45.632] 1. sequential:
[15:32:45.632]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.632]    - tweaked: FALSE
[15:32:45.632]    - call: plan(strategy)
[15:32:45.633] plan(): nbrOfWorkers() = 1
[15:32:45.633] SequentialFuture started (and completed)
[15:32:45.634] - Launch lazy future ... done
[15:32:45.634] run() for 'SequentialFuture' ... done
[15:32:45.634] Created future:
[15:32:45.635] SequentialFuture:
[15:32:45.635] Label: 'future_sapply-1'
[15:32:45.635] Expression:
[15:32:45.635] {
[15:32:45.635]     do.call(function(...) {
[15:32:45.635]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.635]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.635]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.635]             on.exit(options(oopts), add = TRUE)
[15:32:45.635]         }
[15:32:45.635]         {
[15:32:45.635]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.635]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.635]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.635]             })
[15:32:45.635]         }
[15:32:45.635]     }, args = future.call.arguments)
[15:32:45.635] }
[15:32:45.635] Lazy evaluation: FALSE
[15:32:45.635] Asynchronous evaluation: FALSE
[15:32:45.635] Local evaluation: TRUE
[15:32:45.635] Environment: R_GlobalEnv
[15:32:45.635] Capture standard output: TRUE
[15:32:45.635] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:45.635] Globals: 5 objects totaling 4.38 KiB (function '...future.FUN' of 4.07 KiB, DotDotDotList 'future.call.arguments' of 96 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:45.635] Packages: <none>
[15:32:45.635] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:45.635] Resolved: TRUE
[15:32:45.635] Value: 1.34 KiB of class 'list'
[15:32:45.635] Early signaling: FALSE
[15:32:45.635] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:45.635] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.637] Chunk #1 of 1 ... DONE
[15:32:45.637] Launching 1 futures (chunks) ... DONE
[15:32:45.637] Resolving 1 futures (chunks) ...
[15:32:45.638] resolve() on list ...
[15:32:45.638]  recursive: 0
[15:32:45.638]  length: 1
[15:32:45.638] 
[15:32:45.639] resolved() for 'SequentialFuture' ...
[15:32:45.639] - state: 'finished'
[15:32:45.639] - run: TRUE
[15:32:45.640] - result: 'FutureResult'
[15:32:45.640] resolved() for 'SequentialFuture' ... done
[15:32:45.640] Future #1
[15:32:45.641] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:45.641] - nx: 1
[15:32:45.641] - relay: TRUE
[15:32:45.641] - stdout: TRUE
[15:32:45.642] - signal: TRUE
[15:32:45.642] - resignal: FALSE
[15:32:45.642] - force: TRUE
[15:32:45.642] - relayed: [n=1] FALSE
[15:32:45.643] - queued futures: [n=1] FALSE
[15:32:45.643]  - until=1
[15:32:45.643]  - relaying element #1
[15:32:45.644] - relayed: [n=1] TRUE
[15:32:45.644] - queued futures: [n=1] TRUE
[15:32:45.644] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:45.645]  length: 0 (resolved future 1)
[15:32:45.645] Relaying remaining futures
[15:32:45.645] signalConditionsASAP(NULL, pos=0) ...
[15:32:45.645] - nx: 1
[15:32:45.646] - relay: TRUE
[15:32:45.646] - stdout: TRUE
[15:32:45.646] - signal: TRUE
[15:32:45.646] - resignal: FALSE
[15:32:45.646] - force: TRUE
[15:32:45.647] - relayed: [n=1] TRUE
[15:32:45.647] - queued futures: [n=1] TRUE
 - flush all
[15:32:45.647] - relayed: [n=1] TRUE
[15:32:45.648] - queued futures: [n=1] TRUE
[15:32:45.648] signalConditionsASAP(NULL, pos=0) ... done
[15:32:45.648] resolve() on list ... DONE
[15:32:45.649]  - Number of value chunks collected: 1
[15:32:45.649] Resolving 1 futures (chunks) ... DONE
[15:32:45.649] Reducing values from 1 chunks ...
[15:32:45.649]  - Number of values collected after concatenation: 4
[15:32:45.650]  - Number of values expected: 4
[15:32:45.650] Reducing values from 1 chunks ... DONE
[15:32:45.650] future_lapply() ... DONE
[15:32:45.651] future_lapply() ...
[15:32:45.658] Number of chunks: 1
[15:32:45.658] getGlobalsAndPackagesXApply() ...
[15:32:45.658]  - future.globals: TRUE
[15:32:45.659] getGlobalsAndPackages() ...
[15:32:45.659] Searching for globals...
[15:32:45.666] - globals found: [18] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'outer', 'rep'
[15:32:45.667] Searching for globals ... DONE
[15:32:45.667] Resolving globals: FALSE
[15:32:45.669] The total size of the 7 globals is 96.20 KiB (98504 bytes)
[15:32:45.670] The total size of the 7 globals exported for future expression ('FUN(y = c(2, 4, 6, 8, 10))') is 96.20 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:45.670] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:45.670] - packages: [1] 'future.apply'
[15:32:45.670] getGlobalsAndPackages() ... DONE
[15:32:45.671]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:45.671]  - needed namespaces: [n=1] 'future.apply'
[15:32:45.671] Finding globals ... DONE
[15:32:45.671]  - use_args: TRUE
[15:32:45.672]  - Getting '...' globals ...
[15:32:45.672] resolve() on list ...
[15:32:45.673]  recursive: 0
[15:32:45.673]  length: 1
[15:32:45.673]  elements: '...'
[15:32:45.673]  length: 0 (resolved future 1)
[15:32:45.673] resolve() on list ... DONE
[15:32:45.674]    - '...' content: [n=1] 'y'
[15:32:45.674] List of 1
[15:32:45.674]  $ ...:List of 1
[15:32:45.674]   ..$ y: num [1:5] 2 4 6 8 10
[15:32:45.674]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.674]  - attr(*, "where")=List of 1
[15:32:45.674]   ..$ ...:<environment: 0x0000022d3e4706b8> 
[15:32:45.674]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.674]  - attr(*, "resolved")= logi TRUE
[15:32:45.674]  - attr(*, "total_size")= num NA
[15:32:45.679]  - Getting '...' globals ... DONE
[15:32:45.680] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:45.680] List of 8
[15:32:45.680]  $ ...future.FUN:function (x, ...)  
[15:32:45.680]  $ x_FUN        :function (x, y)  
[15:32:45.680]  $ times        : int 15
[15:32:45.680]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.680]  $ stop_if_not  :function (...)  
[15:32:45.680]  $ dim          : int [1:2] 3 5
[15:32:45.680]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:45.680]  $ ...          :List of 1
[15:32:45.680]   ..$ y: num [1:5] 2 4 6 8 10
[15:32:45.680]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.680]  - attr(*, "where")=List of 8
[15:32:45.680]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:45.680]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:45.680]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:45.680]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:45.680]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:45.680]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:45.680]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:45.680]   ..$ ...          :<environment: 0x0000022d3e4706b8> 
[15:32:45.680]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.680]  - attr(*, "resolved")= logi FALSE
[15:32:45.680]  - attr(*, "total_size")= num 98600
[15:32:45.695] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:45.695] getGlobalsAndPackagesXApply() ... DONE
[15:32:45.695] Number of futures (= number of chunks): 1
[15:32:45.696] Launching 1 futures (chunks) ...
[15:32:45.696] Chunk #1 of 1 ...
[15:32:45.696]  - Finding globals in 'X' for chunk #1 ...
[15:32:45.696] getGlobalsAndPackages() ...
[15:32:45.697] Searching for globals...
[15:32:45.697] 
[15:32:45.697] Searching for globals ... DONE
[15:32:45.698] - globals: [0] <none>
[15:32:45.698] getGlobalsAndPackages() ... DONE
[15:32:45.698]    + additional globals found: [n=0] 
[15:32:45.698]    + additional namespaces needed: [n=0] 
[15:32:45.699]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:45.699]  - seeds: <none>
[15:32:45.699]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.699] getGlobalsAndPackages() ...
[15:32:45.700] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.700] Resolving globals: FALSE
[15:32:45.700] Tweak future expression to call with '...' arguments ...
[15:32:45.700] {
[15:32:45.700]     do.call(function(...) {
[15:32:45.700]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.700]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.700]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.700]             on.exit(options(oopts), add = TRUE)
[15:32:45.700]         }
[15:32:45.700]         {
[15:32:45.700]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.700]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.700]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.700]             })
[15:32:45.700]         }
[15:32:45.700]     }, args = future.call.arguments)
[15:32:45.700] }
[15:32:45.701] Tweak future expression to call with '...' arguments ... DONE
[15:32:45.702] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.702] - packages: [1] 'future.apply'
[15:32:45.703] getGlobalsAndPackages() ... DONE
[15:32:45.703] run() for 'Future' ...
[15:32:45.704] - state: 'created'
[15:32:45.704] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:45.704] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.705] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:45.705]   - Field: 'label'
[15:32:45.705]   - Field: 'local'
[15:32:45.706]   - Field: 'owner'
[15:32:45.706]   - Field: 'envir'
[15:32:45.706]   - Field: 'packages'
[15:32:45.706]   - Field: 'gc'
[15:32:45.707]   - Field: 'conditions'
[15:32:45.707]   - Field: 'expr'
[15:32:45.707]   - Field: 'uuid'
[15:32:45.707]   - Field: 'seed'
[15:32:45.708]   - Field: 'version'
[15:32:45.708]   - Field: 'result'
[15:32:45.708]   - Field: 'asynchronous'
[15:32:45.708]   - Field: 'calls'
[15:32:45.709]   - Field: 'globals'
[15:32:45.709]   - Field: 'stdout'
[15:32:45.709]   - Field: 'earlySignal'
[15:32:45.709]   - Field: 'lazy'
[15:32:45.710]   - Field: 'state'
[15:32:45.710] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:45.710] - Launch lazy future ...
[15:32:45.711] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:45.711] Packages needed by future strategies (n = 0): <none>
[15:32:45.712] {
[15:32:45.712]     {
[15:32:45.712]         {
[15:32:45.712]             ...future.startTime <- base::Sys.time()
[15:32:45.712]             {
[15:32:45.712]                 {
[15:32:45.712]                   {
[15:32:45.712]                     {
[15:32:45.712]                       base::local({
[15:32:45.712]                         has_future <- base::requireNamespace("future", 
[15:32:45.712]                           quietly = TRUE)
[15:32:45.712]                         if (has_future) {
[15:32:45.712]                           ns <- base::getNamespace("future")
[15:32:45.712]                           version <- ns[[".package"]][["version"]]
[15:32:45.712]                           if (is.null(version)) 
[15:32:45.712]                             version <- utils::packageVersion("future")
[15:32:45.712]                         }
[15:32:45.712]                         else {
[15:32:45.712]                           version <- NULL
[15:32:45.712]                         }
[15:32:45.712]                         if (!has_future || version < "1.8.0") {
[15:32:45.712]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:45.712]                             "", base::R.version$version.string), 
[15:32:45.712]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:45.712]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:45.712]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:45.712]                               "release", "version")], collapse = " "), 
[15:32:45.712]                             hostname = base::Sys.info()[["nodename"]])
[15:32:45.712]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:45.712]                             info)
[15:32:45.712]                           info <- base::paste(info, collapse = "; ")
[15:32:45.712]                           if (!has_future) {
[15:32:45.712]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:45.712]                               info)
[15:32:45.712]                           }
[15:32:45.712]                           else {
[15:32:45.712]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:45.712]                               info, version)
[15:32:45.712]                           }
[15:32:45.712]                           base::stop(msg)
[15:32:45.712]                         }
[15:32:45.712]                       })
[15:32:45.712]                     }
[15:32:45.712]                     base::local({
[15:32:45.712]                       for (pkg in "future.apply") {
[15:32:45.712]                         base::loadNamespace(pkg)
[15:32:45.712]                         base::library(pkg, character.only = TRUE)
[15:32:45.712]                       }
[15:32:45.712]                     })
[15:32:45.712]                   }
[15:32:45.712]                   ...future.strategy.old <- future::plan("list")
[15:32:45.712]                   options(future.plan = NULL)
[15:32:45.712]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.712]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:45.712]                 }
[15:32:45.712]                 ...future.workdir <- getwd()
[15:32:45.712]             }
[15:32:45.712]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:45.712]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:45.712]         }
[15:32:45.712]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:45.712]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:45.712]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:45.712]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:45.712]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:45.712]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:45.712]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:45.712]             base::names(...future.oldOptions))
[15:32:45.712]     }
[15:32:45.712]     if (FALSE) {
[15:32:45.712]     }
[15:32:45.712]     else {
[15:32:45.712]         if (TRUE) {
[15:32:45.712]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:45.712]                 open = "w")
[15:32:45.712]         }
[15:32:45.712]         else {
[15:32:45.712]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:45.712]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:45.712]         }
[15:32:45.712]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:45.712]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:45.712]             base::sink(type = "output", split = FALSE)
[15:32:45.712]             base::close(...future.stdout)
[15:32:45.712]         }, add = TRUE)
[15:32:45.712]     }
[15:32:45.712]     ...future.frame <- base::sys.nframe()
[15:32:45.712]     ...future.conditions <- base::list()
[15:32:45.712]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:45.712]     if (FALSE) {
[15:32:45.712]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:45.712]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:45.712]     }
[15:32:45.712]     ...future.result <- base::tryCatch({
[15:32:45.712]         base::withCallingHandlers({
[15:32:45.712]             ...future.value <- base::withVisible(base::local({
[15:32:45.712]                 do.call(function(...) {
[15:32:45.712]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.712]                   if (!identical(...future.globals.maxSize.org, 
[15:32:45.712]                     ...future.globals.maxSize)) {
[15:32:45.712]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.712]                     on.exit(options(oopts), add = TRUE)
[15:32:45.712]                   }
[15:32:45.712]                   {
[15:32:45.712]                     lapply(seq_along(...future.elements_ii), 
[15:32:45.712]                       FUN = function(jj) {
[15:32:45.712]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.712]                         ...future.FUN(...future.X_jj, ...)
[15:32:45.712]                       })
[15:32:45.712]                   }
[15:32:45.712]                 }, args = future.call.arguments)
[15:32:45.712]             }))
[15:32:45.712]             future::FutureResult(value = ...future.value$value, 
[15:32:45.712]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.712]                   ...future.rng), globalenv = if (FALSE) 
[15:32:45.712]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:45.712]                     ...future.globalenv.names))
[15:32:45.712]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:45.712]         }, condition = base::local({
[15:32:45.712]             c <- base::c
[15:32:45.712]             inherits <- base::inherits
[15:32:45.712]             invokeRestart <- base::invokeRestart
[15:32:45.712]             length <- base::length
[15:32:45.712]             list <- base::list
[15:32:45.712]             seq.int <- base::seq.int
[15:32:45.712]             signalCondition <- base::signalCondition
[15:32:45.712]             sys.calls <- base::sys.calls
[15:32:45.712]             `[[` <- base::`[[`
[15:32:45.712]             `+` <- base::`+`
[15:32:45.712]             `<<-` <- base::`<<-`
[15:32:45.712]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:45.712]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:45.712]                   3L)]
[15:32:45.712]             }
[15:32:45.712]             function(cond) {
[15:32:45.712]                 is_error <- inherits(cond, "error")
[15:32:45.712]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:45.712]                   NULL)
[15:32:45.712]                 if (is_error) {
[15:32:45.712]                   sessionInformation <- function() {
[15:32:45.712]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:45.712]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:45.712]                       search = base::search(), system = base::Sys.info())
[15:32:45.712]                   }
[15:32:45.712]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.712]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:45.712]                     cond$call), session = sessionInformation(), 
[15:32:45.712]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:45.712]                   signalCondition(cond)
[15:32:45.712]                 }
[15:32:45.712]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:45.712]                 "immediateCondition"))) {
[15:32:45.712]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:45.712]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.712]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:45.712]                   if (TRUE && !signal) {
[15:32:45.712]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.712]                     {
[15:32:45.712]                       inherits <- base::inherits
[15:32:45.712]                       invokeRestart <- base::invokeRestart
[15:32:45.712]                       is.null <- base::is.null
[15:32:45.712]                       muffled <- FALSE
[15:32:45.712]                       if (inherits(cond, "message")) {
[15:32:45.712]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.712]                         if (muffled) 
[15:32:45.712]                           invokeRestart("muffleMessage")
[15:32:45.712]                       }
[15:32:45.712]                       else if (inherits(cond, "warning")) {
[15:32:45.712]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.712]                         if (muffled) 
[15:32:45.712]                           invokeRestart("muffleWarning")
[15:32:45.712]                       }
[15:32:45.712]                       else if (inherits(cond, "condition")) {
[15:32:45.712]                         if (!is.null(pattern)) {
[15:32:45.712]                           computeRestarts <- base::computeRestarts
[15:32:45.712]                           grepl <- base::grepl
[15:32:45.712]                           restarts <- computeRestarts(cond)
[15:32:45.712]                           for (restart in restarts) {
[15:32:45.712]                             name <- restart$name
[15:32:45.712]                             if (is.null(name)) 
[15:32:45.712]                               next
[15:32:45.712]                             if (!grepl(pattern, name)) 
[15:32:45.712]                               next
[15:32:45.712]                             invokeRestart(restart)
[15:32:45.712]                             muffled <- TRUE
[15:32:45.712]                             break
[15:32:45.712]                           }
[15:32:45.712]                         }
[15:32:45.712]                       }
[15:32:45.712]                       invisible(muffled)
[15:32:45.712]                     }
[15:32:45.712]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.712]                   }
[15:32:45.712]                 }
[15:32:45.712]                 else {
[15:32:45.712]                   if (TRUE) {
[15:32:45.712]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.712]                     {
[15:32:45.712]                       inherits <- base::inherits
[15:32:45.712]                       invokeRestart <- base::invokeRestart
[15:32:45.712]                       is.null <- base::is.null
[15:32:45.712]                       muffled <- FALSE
[15:32:45.712]                       if (inherits(cond, "message")) {
[15:32:45.712]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.712]                         if (muffled) 
[15:32:45.712]                           invokeRestart("muffleMessage")
[15:32:45.712]                       }
[15:32:45.712]                       else if (inherits(cond, "warning")) {
[15:32:45.712]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.712]                         if (muffled) 
[15:32:45.712]                           invokeRestart("muffleWarning")
[15:32:45.712]                       }
[15:32:45.712]                       else if (inherits(cond, "condition")) {
[15:32:45.712]                         if (!is.null(pattern)) {
[15:32:45.712]                           computeRestarts <- base::computeRestarts
[15:32:45.712]                           grepl <- base::grepl
[15:32:45.712]                           restarts <- computeRestarts(cond)
[15:32:45.712]                           for (restart in restarts) {
[15:32:45.712]                             name <- restart$name
[15:32:45.712]                             if (is.null(name)) 
[15:32:45.712]                               next
[15:32:45.712]                             if (!grepl(pattern, name)) 
[15:32:45.712]                               next
[15:32:45.712]                             invokeRestart(restart)
[15:32:45.712]                             muffled <- TRUE
[15:32:45.712]                             break
[15:32:45.712]                           }
[15:32:45.712]                         }
[15:32:45.712]                       }
[15:32:45.712]                       invisible(muffled)
[15:32:45.712]                     }
[15:32:45.712]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.712]                   }
[15:32:45.712]                 }
[15:32:45.712]             }
[15:32:45.712]         }))
[15:32:45.712]     }, error = function(ex) {
[15:32:45.712]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:45.712]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.712]                 ...future.rng), started = ...future.startTime, 
[15:32:45.712]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:45.712]             version = "1.8"), class = "FutureResult")
[15:32:45.712]     }, finally = {
[15:32:45.712]         if (!identical(...future.workdir, getwd())) 
[15:32:45.712]             setwd(...future.workdir)
[15:32:45.712]         {
[15:32:45.712]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:45.712]                 ...future.oldOptions$nwarnings <- NULL
[15:32:45.712]             }
[15:32:45.712]             base::options(...future.oldOptions)
[15:32:45.712]             if (.Platform$OS.type == "windows") {
[15:32:45.712]                 old_names <- names(...future.oldEnvVars)
[15:32:45.712]                 envs <- base::Sys.getenv()
[15:32:45.712]                 names <- names(envs)
[15:32:45.712]                 common <- intersect(names, old_names)
[15:32:45.712]                 added <- setdiff(names, old_names)
[15:32:45.712]                 removed <- setdiff(old_names, names)
[15:32:45.712]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:45.712]                   envs[common]]
[15:32:45.712]                 NAMES <- toupper(changed)
[15:32:45.712]                 args <- list()
[15:32:45.712]                 for (kk in seq_along(NAMES)) {
[15:32:45.712]                   name <- changed[[kk]]
[15:32:45.712]                   NAME <- NAMES[[kk]]
[15:32:45.712]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.712]                     next
[15:32:45.712]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.712]                 }
[15:32:45.712]                 NAMES <- toupper(added)
[15:32:45.712]                 for (kk in seq_along(NAMES)) {
[15:32:45.712]                   name <- added[[kk]]
[15:32:45.712]                   NAME <- NAMES[[kk]]
[15:32:45.712]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.712]                     next
[15:32:45.712]                   args[[name]] <- ""
[15:32:45.712]                 }
[15:32:45.712]                 NAMES <- toupper(removed)
[15:32:45.712]                 for (kk in seq_along(NAMES)) {
[15:32:45.712]                   name <- removed[[kk]]
[15:32:45.712]                   NAME <- NAMES[[kk]]
[15:32:45.712]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.712]                     next
[15:32:45.712]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.712]                 }
[15:32:45.712]                 if (length(args) > 0) 
[15:32:45.712]                   base::do.call(base::Sys.setenv, args = args)
[15:32:45.712]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:45.712]             }
[15:32:45.712]             else {
[15:32:45.712]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:45.712]             }
[15:32:45.712]             {
[15:32:45.712]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:45.712]                   0L) {
[15:32:45.712]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:45.712]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:45.712]                   base::options(opts)
[15:32:45.712]                 }
[15:32:45.712]                 {
[15:32:45.712]                   {
[15:32:45.712]                     NULL
[15:32:45.712]                     RNGkind("Mersenne-Twister")
[15:32:45.712]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:45.712]                       inherits = FALSE)
[15:32:45.712]                   }
[15:32:45.712]                   options(future.plan = NULL)
[15:32:45.712]                   if (is.na(NA_character_)) 
[15:32:45.712]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.712]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:45.712]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:45.712]                     .init = FALSE)
[15:32:45.712]                 }
[15:32:45.712]             }
[15:32:45.712]         }
[15:32:45.712]     })
[15:32:45.712]     if (TRUE) {
[15:32:45.712]         base::sink(type = "output", split = FALSE)
[15:32:45.712]         if (TRUE) {
[15:32:45.712]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:45.712]         }
[15:32:45.712]         else {
[15:32:45.712]             ...future.result["stdout"] <- base::list(NULL)
[15:32:45.712]         }
[15:32:45.712]         base::close(...future.stdout)
[15:32:45.712]         ...future.stdout <- NULL
[15:32:45.712]     }
[15:32:45.712]     ...future.result$conditions <- ...future.conditions
[15:32:45.712]     ...future.result$finished <- base::Sys.time()
[15:32:45.712]     ...future.result
[15:32:45.712] }
[15:32:45.718] assign_globals() ...
[15:32:45.718] List of 11
[15:32:45.718]  $ ...future.FUN            :function (x, ...)  
[15:32:45.718]  $ x_FUN                    :function (x, y)  
[15:32:45.718]  $ times                    : int 15
[15:32:45.718]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.718]  $ stop_if_not              :function (...)  
[15:32:45.718]  $ dim                      : int [1:2] 3 5
[15:32:45.718]  $ valid_types              : chr [1:3] "logical" "integer" "double"
[15:32:45.718]  $ future.call.arguments    :List of 1
[15:32:45.718]   ..$ y: num [1:5] 2 4 6 8 10
[15:32:45.718]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.718]  $ ...future.elements_ii    :List of 4
[15:32:45.718]   ..$ A: num 50
[15:32:45.718]   ..$ B: num 60
[15:32:45.718]   ..$ C: num 70
[15:32:45.718]   ..$ D: num 80
[15:32:45.718]  $ ...future.seeds_ii       : NULL
[15:32:45.718]  $ ...future.globals.maxSize: NULL
[15:32:45.718]  - attr(*, "where")=List of 11
[15:32:45.718]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:45.718]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:45.718]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:45.718]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:45.718]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:45.718]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:45.718]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:45.718]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:45.718]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:45.718]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:45.718]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:45.718]  - attr(*, "resolved")= logi FALSE
[15:32:45.718]  - attr(*, "total_size")= num 98600
[15:32:45.718]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.718]  - attr(*, "already-done")= logi TRUE
[15:32:45.739] - copied '...future.FUN' to environment
[15:32:45.739] - reassign environment for 'x_FUN'
[15:32:45.739] - copied 'x_FUN' to environment
[15:32:45.739] - copied 'times' to environment
[15:32:45.740] - copied 'stopf' to environment
[15:32:45.740] - copied 'stop_if_not' to environment
[15:32:45.740] - copied 'dim' to environment
[15:32:45.740] - copied 'valid_types' to environment
[15:32:45.740] - copied 'future.call.arguments' to environment
[15:32:45.741] - copied '...future.elements_ii' to environment
[15:32:45.741] - copied '...future.seeds_ii' to environment
[15:32:45.741] - copied '...future.globals.maxSize' to environment
[15:32:45.741] assign_globals() ... done
[15:32:45.742] plan(): Setting new future strategy stack:
[15:32:45.742] List of future strategies:
[15:32:45.742] 1. sequential:
[15:32:45.742]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.742]    - tweaked: FALSE
[15:32:45.742]    - call: NULL
[15:32:45.743] plan(): nbrOfWorkers() = 1
[15:32:45.745] plan(): Setting new future strategy stack:
[15:32:45.745] List of future strategies:
[15:32:45.745] 1. sequential:
[15:32:45.745]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.745]    - tweaked: FALSE
[15:32:45.745]    - call: plan(strategy)
[15:32:45.746] plan(): nbrOfWorkers() = 1
[15:32:45.746] SequentialFuture started (and completed)
[15:32:45.747] - Launch lazy future ... done
[15:32:45.747] run() for 'SequentialFuture' ... done
[15:32:45.747] Created future:
[15:32:45.747] SequentialFuture:
[15:32:45.747] Label: 'future_vapply-1'
[15:32:45.747] Expression:
[15:32:45.747] {
[15:32:45.747]     do.call(function(...) {
[15:32:45.747]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.747]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.747]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.747]             on.exit(options(oopts), add = TRUE)
[15:32:45.747]         }
[15:32:45.747]         {
[15:32:45.747]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.747]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.747]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.747]             })
[15:32:45.747]         }
[15:32:45.747]     }, args = future.call.arguments)
[15:32:45.747] }
[15:32:45.747] Lazy evaluation: FALSE
[15:32:45.747] Asynchronous evaluation: FALSE
[15:32:45.747] Local evaluation: TRUE
[15:32:45.747] Environment: R_GlobalEnv
[15:32:45.747] Capture standard output: TRUE
[15:32:45.747] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:45.747] Globals: 11 objects totaling 96.51 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 4.07 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:45.747] Packages: 1 packages ('future.apply')
[15:32:45.747] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:45.747] Resolved: TRUE
[15:32:45.747] Value: 1.34 KiB of class 'list'
[15:32:45.747] Early signaling: FALSE
[15:32:45.747] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:45.747] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.749] Chunk #1 of 1 ... DONE
[15:32:45.750] Launching 1 futures (chunks) ... DONE
[15:32:45.750] Resolving 1 futures (chunks) ...
[15:32:45.750] resolve() on list ...
[15:32:45.750]  recursive: 0
[15:32:45.750]  length: 1
[15:32:45.751] 
[15:32:45.751] resolved() for 'SequentialFuture' ...
[15:32:45.751] - state: 'finished'
[15:32:45.751] - run: TRUE
[15:32:45.752] - result: 'FutureResult'
[15:32:45.752] resolved() for 'SequentialFuture' ... done
[15:32:45.752] Future #1
[15:32:45.753] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:45.753] - nx: 1
[15:32:45.753] - relay: TRUE
[15:32:45.753] - stdout: TRUE
[15:32:45.754] - signal: TRUE
[15:32:45.754] - resignal: FALSE
[15:32:45.754] - force: TRUE
[15:32:45.754] - relayed: [n=1] FALSE
[15:32:45.754] - queued futures: [n=1] FALSE
[15:32:45.754]  - until=1
[15:32:45.755]  - relaying element #1
[15:32:45.755] - relayed: [n=1] TRUE
[15:32:45.755] - queued futures: [n=1] TRUE
[15:32:45.755] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:45.756]  length: 0 (resolved future 1)
[15:32:45.756] Relaying remaining futures
[15:32:45.756] signalConditionsASAP(NULL, pos=0) ...
[15:32:45.756] - nx: 1
[15:32:45.756] - relay: TRUE
[15:32:45.756] - stdout: TRUE
[15:32:45.757] - signal: TRUE
[15:32:45.757] - resignal: FALSE
[15:32:45.757] - force: TRUE
[15:32:45.757] - relayed: [n=1] TRUE
[15:32:45.757] - queued futures: [n=1] TRUE
 - flush all
[15:32:45.757] - relayed: [n=1] TRUE
[15:32:45.758] - queued futures: [n=1] TRUE
[15:32:45.758] signalConditionsASAP(NULL, pos=0) ... done
[15:32:45.758] resolve() on list ... DONE
[15:32:45.758]  - Number of value chunks collected: 1
[15:32:45.758] Resolving 1 futures (chunks) ... DONE
[15:32:45.759] Reducing values from 1 chunks ...
[15:32:45.759]  - Number of values collected after concatenation: 4
[15:32:45.759]  - Number of values expected: 4
[15:32:45.759] Reducing values from 1 chunks ... DONE
[15:32:45.759] future_lapply() ... DONE
 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"
[15:32:45.762] future_lapply() ...
[15:32:45.767] Number of chunks: 1
[15:32:45.768] getGlobalsAndPackagesXApply() ...
[15:32:45.768]  - future.globals: TRUE
[15:32:45.768] getGlobalsAndPackages() ...
[15:32:45.768] Searching for globals...
[15:32:45.774] - globals found: [16] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types'
[15:32:45.775] Searching for globals ... DONE
[15:32:45.775] Resolving globals: FALSE
[15:32:45.777] The total size of the 7 globals is 91.99 KiB (94200 bytes)
[15:32:45.778] The total size of the 7 globals exported for future expression ('FUN()') is 91.99 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:45.778] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:45.779] - packages: [1] 'future.apply'
[15:32:45.779] getGlobalsAndPackages() ... DONE
[15:32:45.779]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:45.779]  - needed namespaces: [n=1] 'future.apply'
[15:32:45.780] Finding globals ... DONE
[15:32:45.780]  - use_args: TRUE
[15:32:45.780]  - Getting '...' globals ...
[15:32:45.781] resolve() on list ...
[15:32:45.781]  recursive: 0
[15:32:45.782]  length: 1
[15:32:45.782]  elements: '...'
[15:32:45.782]  length: 0 (resolved future 1)
[15:32:45.782] resolve() on list ... DONE
[15:32:45.783]    - '...' content: [n=0] 
[15:32:45.783] List of 1
[15:32:45.783]  $ ...: list()
[15:32:45.783]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.783]  - attr(*, "where")=List of 1
[15:32:45.783]   ..$ ...:<environment: 0x0000022d3e564aa8> 
[15:32:45.783]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.783]  - attr(*, "resolved")= logi TRUE
[15:32:45.783]  - attr(*, "total_size")= num NA
[15:32:45.788]  - Getting '...' globals ... DONE
[15:32:45.789] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:45.789] List of 8
[15:32:45.789]  $ ...future.FUN:function (x, ...)  
[15:32:45.789]  $ x_FUN        :function (x)  
[15:32:45.789]  $ times        : int 1
[15:32:45.789]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.789]  $ stop_if_not  :function (...)  
[15:32:45.789]  $ dim          : NULL
[15:32:45.789]  $ valid_types  : chr "logical"
[15:32:45.789]  $ ...          : list()
[15:32:45.789]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.789]  - attr(*, "where")=List of 8
[15:32:45.789]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:45.789]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:45.789]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:45.789]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:45.789]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:45.789]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:45.789]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:45.789]   ..$ ...          :<environment: 0x0000022d3e564aa8> 
[15:32:45.789]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.789]  - attr(*, "resolved")= logi FALSE
[15:32:45.789]  - attr(*, "total_size")= num 94200
[15:32:45.803] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:45.803] getGlobalsAndPackagesXApply() ... DONE
[15:32:45.804] Number of futures (= number of chunks): 1
[15:32:45.804] Launching 1 futures (chunks) ...
[15:32:45.805] Chunk #1 of 1 ...
[15:32:45.805]  - Finding globals in 'X' for chunk #1 ...
[15:32:45.805] getGlobalsAndPackages() ...
[15:32:45.806] Searching for globals...
[15:32:45.806] 
[15:32:45.807] Searching for globals ... DONE
[15:32:45.807] - globals: [0] <none>
[15:32:45.807] getGlobalsAndPackages() ... DONE
[15:32:45.807]    + additional globals found: [n=0] 
[15:32:45.808]    + additional namespaces needed: [n=0] 
[15:32:45.808]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:45.808]  - seeds: <none>
[15:32:45.809]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.809] getGlobalsAndPackages() ...
[15:32:45.809] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.810] Resolving globals: FALSE
[15:32:45.810] Tweak future expression to call with '...' arguments ...
[15:32:45.810] {
[15:32:45.810]     do.call(function(...) {
[15:32:45.810]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.810]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.810]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.810]             on.exit(options(oopts), add = TRUE)
[15:32:45.810]         }
[15:32:45.810]         {
[15:32:45.810]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.810]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.810]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.810]             })
[15:32:45.810]         }
[15:32:45.810]     }, args = future.call.arguments)
[15:32:45.810] }
[15:32:45.811] Tweak future expression to call with '...' arguments ... DONE
[15:32:45.813] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.813] - packages: [1] 'future.apply'
[15:32:45.813] getGlobalsAndPackages() ... DONE
[15:32:45.814] run() for 'Future' ...
[15:32:45.814] - state: 'created'
[15:32:45.815] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:45.815] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.816] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:45.816]   - Field: 'label'
[15:32:45.816]   - Field: 'local'
[15:32:45.817]   - Field: 'owner'
[15:32:45.817]   - Field: 'envir'
[15:32:45.817]   - Field: 'packages'
[15:32:45.818]   - Field: 'gc'
[15:32:45.818]   - Field: 'conditions'
[15:32:45.818]   - Field: 'expr'
[15:32:45.818]   - Field: 'uuid'
[15:32:45.819]   - Field: 'seed'
[15:32:45.819]   - Field: 'version'
[15:32:45.819]   - Field: 'result'
[15:32:45.820]   - Field: 'asynchronous'
[15:32:45.820]   - Field: 'calls'
[15:32:45.820]   - Field: 'globals'
[15:32:45.820]   - Field: 'stdout'
[15:32:45.821]   - Field: 'earlySignal'
[15:32:45.821]   - Field: 'lazy'
[15:32:45.821]   - Field: 'state'
[15:32:45.822] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:45.822] - Launch lazy future ...
[15:32:45.822] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:45.823] Packages needed by future strategies (n = 0): <none>
[15:32:45.824] {
[15:32:45.824]     {
[15:32:45.824]         {
[15:32:45.824]             ...future.startTime <- base::Sys.time()
[15:32:45.824]             {
[15:32:45.824]                 {
[15:32:45.824]                   {
[15:32:45.824]                     {
[15:32:45.824]                       base::local({
[15:32:45.824]                         has_future <- base::requireNamespace("future", 
[15:32:45.824]                           quietly = TRUE)
[15:32:45.824]                         if (has_future) {
[15:32:45.824]                           ns <- base::getNamespace("future")
[15:32:45.824]                           version <- ns[[".package"]][["version"]]
[15:32:45.824]                           if (is.null(version)) 
[15:32:45.824]                             version <- utils::packageVersion("future")
[15:32:45.824]                         }
[15:32:45.824]                         else {
[15:32:45.824]                           version <- NULL
[15:32:45.824]                         }
[15:32:45.824]                         if (!has_future || version < "1.8.0") {
[15:32:45.824]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:45.824]                             "", base::R.version$version.string), 
[15:32:45.824]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:45.824]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:45.824]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:45.824]                               "release", "version")], collapse = " "), 
[15:32:45.824]                             hostname = base::Sys.info()[["nodename"]])
[15:32:45.824]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:45.824]                             info)
[15:32:45.824]                           info <- base::paste(info, collapse = "; ")
[15:32:45.824]                           if (!has_future) {
[15:32:45.824]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:45.824]                               info)
[15:32:45.824]                           }
[15:32:45.824]                           else {
[15:32:45.824]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:45.824]                               info, version)
[15:32:45.824]                           }
[15:32:45.824]                           base::stop(msg)
[15:32:45.824]                         }
[15:32:45.824]                       })
[15:32:45.824]                     }
[15:32:45.824]                     base::local({
[15:32:45.824]                       for (pkg in "future.apply") {
[15:32:45.824]                         base::loadNamespace(pkg)
[15:32:45.824]                         base::library(pkg, character.only = TRUE)
[15:32:45.824]                       }
[15:32:45.824]                     })
[15:32:45.824]                   }
[15:32:45.824]                   ...future.strategy.old <- future::plan("list")
[15:32:45.824]                   options(future.plan = NULL)
[15:32:45.824]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.824]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:45.824]                 }
[15:32:45.824]                 ...future.workdir <- getwd()
[15:32:45.824]             }
[15:32:45.824]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:45.824]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:45.824]         }
[15:32:45.824]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:45.824]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:45.824]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:45.824]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:45.824]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:45.824]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:45.824]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:45.824]             base::names(...future.oldOptions))
[15:32:45.824]     }
[15:32:45.824]     if (FALSE) {
[15:32:45.824]     }
[15:32:45.824]     else {
[15:32:45.824]         if (TRUE) {
[15:32:45.824]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:45.824]                 open = "w")
[15:32:45.824]         }
[15:32:45.824]         else {
[15:32:45.824]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:45.824]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:45.824]         }
[15:32:45.824]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:45.824]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:45.824]             base::sink(type = "output", split = FALSE)
[15:32:45.824]             base::close(...future.stdout)
[15:32:45.824]         }, add = TRUE)
[15:32:45.824]     }
[15:32:45.824]     ...future.frame <- base::sys.nframe()
[15:32:45.824]     ...future.conditions <- base::list()
[15:32:45.824]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:45.824]     if (FALSE) {
[15:32:45.824]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:45.824]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:45.824]     }
[15:32:45.824]     ...future.result <- base::tryCatch({
[15:32:45.824]         base::withCallingHandlers({
[15:32:45.824]             ...future.value <- base::withVisible(base::local({
[15:32:45.824]                 do.call(function(...) {
[15:32:45.824]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.824]                   if (!identical(...future.globals.maxSize.org, 
[15:32:45.824]                     ...future.globals.maxSize)) {
[15:32:45.824]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.824]                     on.exit(options(oopts), add = TRUE)
[15:32:45.824]                   }
[15:32:45.824]                   {
[15:32:45.824]                     lapply(seq_along(...future.elements_ii), 
[15:32:45.824]                       FUN = function(jj) {
[15:32:45.824]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.824]                         ...future.FUN(...future.X_jj, ...)
[15:32:45.824]                       })
[15:32:45.824]                   }
[15:32:45.824]                 }, args = future.call.arguments)
[15:32:45.824]             }))
[15:32:45.824]             future::FutureResult(value = ...future.value$value, 
[15:32:45.824]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.824]                   ...future.rng), globalenv = if (FALSE) 
[15:32:45.824]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:45.824]                     ...future.globalenv.names))
[15:32:45.824]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:45.824]         }, condition = base::local({
[15:32:45.824]             c <- base::c
[15:32:45.824]             inherits <- base::inherits
[15:32:45.824]             invokeRestart <- base::invokeRestart
[15:32:45.824]             length <- base::length
[15:32:45.824]             list <- base::list
[15:32:45.824]             seq.int <- base::seq.int
[15:32:45.824]             signalCondition <- base::signalCondition
[15:32:45.824]             sys.calls <- base::sys.calls
[15:32:45.824]             `[[` <- base::`[[`
[15:32:45.824]             `+` <- base::`+`
[15:32:45.824]             `<<-` <- base::`<<-`
[15:32:45.824]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:45.824]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:45.824]                   3L)]
[15:32:45.824]             }
[15:32:45.824]             function(cond) {
[15:32:45.824]                 is_error <- inherits(cond, "error")
[15:32:45.824]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:45.824]                   NULL)
[15:32:45.824]                 if (is_error) {
[15:32:45.824]                   sessionInformation <- function() {
[15:32:45.824]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:45.824]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:45.824]                       search = base::search(), system = base::Sys.info())
[15:32:45.824]                   }
[15:32:45.824]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.824]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:45.824]                     cond$call), session = sessionInformation(), 
[15:32:45.824]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:45.824]                   signalCondition(cond)
[15:32:45.824]                 }
[15:32:45.824]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:45.824]                 "immediateCondition"))) {
[15:32:45.824]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:45.824]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.824]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:45.824]                   if (TRUE && !signal) {
[15:32:45.824]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.824]                     {
[15:32:45.824]                       inherits <- base::inherits
[15:32:45.824]                       invokeRestart <- base::invokeRestart
[15:32:45.824]                       is.null <- base::is.null
[15:32:45.824]                       muffled <- FALSE
[15:32:45.824]                       if (inherits(cond, "message")) {
[15:32:45.824]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.824]                         if (muffled) 
[15:32:45.824]                           invokeRestart("muffleMessage")
[15:32:45.824]                       }
[15:32:45.824]                       else if (inherits(cond, "warning")) {
[15:32:45.824]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.824]                         if (muffled) 
[15:32:45.824]                           invokeRestart("muffleWarning")
[15:32:45.824]                       }
[15:32:45.824]                       else if (inherits(cond, "condition")) {
[15:32:45.824]                         if (!is.null(pattern)) {
[15:32:45.824]                           computeRestarts <- base::computeRestarts
[15:32:45.824]                           grepl <- base::grepl
[15:32:45.824]                           restarts <- computeRestarts(cond)
[15:32:45.824]                           for (restart in restarts) {
[15:32:45.824]                             name <- restart$name
[15:32:45.824]                             if (is.null(name)) 
[15:32:45.824]                               next
[15:32:45.824]                             if (!grepl(pattern, name)) 
[15:32:45.824]                               next
[15:32:45.824]                             invokeRestart(restart)
[15:32:45.824]                             muffled <- TRUE
[15:32:45.824]                             break
[15:32:45.824]                           }
[15:32:45.824]                         }
[15:32:45.824]                       }
[15:32:45.824]                       invisible(muffled)
[15:32:45.824]                     }
[15:32:45.824]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.824]                   }
[15:32:45.824]                 }
[15:32:45.824]                 else {
[15:32:45.824]                   if (TRUE) {
[15:32:45.824]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.824]                     {
[15:32:45.824]                       inherits <- base::inherits
[15:32:45.824]                       invokeRestart <- base::invokeRestart
[15:32:45.824]                       is.null <- base::is.null
[15:32:45.824]                       muffled <- FALSE
[15:32:45.824]                       if (inherits(cond, "message")) {
[15:32:45.824]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.824]                         if (muffled) 
[15:32:45.824]                           invokeRestart("muffleMessage")
[15:32:45.824]                       }
[15:32:45.824]                       else if (inherits(cond, "warning")) {
[15:32:45.824]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.824]                         if (muffled) 
[15:32:45.824]                           invokeRestart("muffleWarning")
[15:32:45.824]                       }
[15:32:45.824]                       else if (inherits(cond, "condition")) {
[15:32:45.824]                         if (!is.null(pattern)) {
[15:32:45.824]                           computeRestarts <- base::computeRestarts
[15:32:45.824]                           grepl <- base::grepl
[15:32:45.824]                           restarts <- computeRestarts(cond)
[15:32:45.824]                           for (restart in restarts) {
[15:32:45.824]                             name <- restart$name
[15:32:45.824]                             if (is.null(name)) 
[15:32:45.824]                               next
[15:32:45.824]                             if (!grepl(pattern, name)) 
[15:32:45.824]                               next
[15:32:45.824]                             invokeRestart(restart)
[15:32:45.824]                             muffled <- TRUE
[15:32:45.824]                             break
[15:32:45.824]                           }
[15:32:45.824]                         }
[15:32:45.824]                       }
[15:32:45.824]                       invisible(muffled)
[15:32:45.824]                     }
[15:32:45.824]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.824]                   }
[15:32:45.824]                 }
[15:32:45.824]             }
[15:32:45.824]         }))
[15:32:45.824]     }, error = function(ex) {
[15:32:45.824]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:45.824]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.824]                 ...future.rng), started = ...future.startTime, 
[15:32:45.824]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:45.824]             version = "1.8"), class = "FutureResult")
[15:32:45.824]     }, finally = {
[15:32:45.824]         if (!identical(...future.workdir, getwd())) 
[15:32:45.824]             setwd(...future.workdir)
[15:32:45.824]         {
[15:32:45.824]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:45.824]                 ...future.oldOptions$nwarnings <- NULL
[15:32:45.824]             }
[15:32:45.824]             base::options(...future.oldOptions)
[15:32:45.824]             if (.Platform$OS.type == "windows") {
[15:32:45.824]                 old_names <- names(...future.oldEnvVars)
[15:32:45.824]                 envs <- base::Sys.getenv()
[15:32:45.824]                 names <- names(envs)
[15:32:45.824]                 common <- intersect(names, old_names)
[15:32:45.824]                 added <- setdiff(names, old_names)
[15:32:45.824]                 removed <- setdiff(old_names, names)
[15:32:45.824]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:45.824]                   envs[common]]
[15:32:45.824]                 NAMES <- toupper(changed)
[15:32:45.824]                 args <- list()
[15:32:45.824]                 for (kk in seq_along(NAMES)) {
[15:32:45.824]                   name <- changed[[kk]]
[15:32:45.824]                   NAME <- NAMES[[kk]]
[15:32:45.824]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.824]                     next
[15:32:45.824]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.824]                 }
[15:32:45.824]                 NAMES <- toupper(added)
[15:32:45.824]                 for (kk in seq_along(NAMES)) {
[15:32:45.824]                   name <- added[[kk]]
[15:32:45.824]                   NAME <- NAMES[[kk]]
[15:32:45.824]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.824]                     next
[15:32:45.824]                   args[[name]] <- ""
[15:32:45.824]                 }
[15:32:45.824]                 NAMES <- toupper(removed)
[15:32:45.824]                 for (kk in seq_along(NAMES)) {
[15:32:45.824]                   name <- removed[[kk]]
[15:32:45.824]                   NAME <- NAMES[[kk]]
[15:32:45.824]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.824]                     next
[15:32:45.824]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.824]                 }
[15:32:45.824]                 if (length(args) > 0) 
[15:32:45.824]                   base::do.call(base::Sys.setenv, args = args)
[15:32:45.824]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:45.824]             }
[15:32:45.824]             else {
[15:32:45.824]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:45.824]             }
[15:32:45.824]             {
[15:32:45.824]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:45.824]                   0L) {
[15:32:45.824]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:45.824]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:45.824]                   base::options(opts)
[15:32:45.824]                 }
[15:32:45.824]                 {
[15:32:45.824]                   {
[15:32:45.824]                     NULL
[15:32:45.824]                     RNGkind("Mersenne-Twister")
[15:32:45.824]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:45.824]                       inherits = FALSE)
[15:32:45.824]                   }
[15:32:45.824]                   options(future.plan = NULL)
[15:32:45.824]                   if (is.na(NA_character_)) 
[15:32:45.824]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.824]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:45.824]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:45.824]                     .init = FALSE)
[15:32:45.824]                 }
[15:32:45.824]             }
[15:32:45.824]         }
[15:32:45.824]     })
[15:32:45.824]     if (TRUE) {
[15:32:45.824]         base::sink(type = "output", split = FALSE)
[15:32:45.824]         if (TRUE) {
[15:32:45.824]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:45.824]         }
[15:32:45.824]         else {
[15:32:45.824]             ...future.result["stdout"] <- base::list(NULL)
[15:32:45.824]         }
[15:32:45.824]         base::close(...future.stdout)
[15:32:45.824]         ...future.stdout <- NULL
[15:32:45.824]     }
[15:32:45.824]     ...future.result$conditions <- ...future.conditions
[15:32:45.824]     ...future.result$finished <- base::Sys.time()
[15:32:45.824]     ...future.result
[15:32:45.824] }
[15:32:45.831] assign_globals() ...
[15:32:45.831] List of 11
[15:32:45.831]  $ ...future.FUN            :function (x, ...)  
[15:32:45.831]  $ x_FUN                    :function (x)  
[15:32:45.831]  $ times                    : int 1
[15:32:45.831]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.831]  $ stop_if_not              :function (...)  
[15:32:45.831]  $ dim                      : NULL
[15:32:45.831]  $ valid_types              : chr "logical"
[15:32:45.831]  $ future.call.arguments    : list()
[15:32:45.831]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.831]  $ ...future.elements_ii    :List of 11
[15:32:45.831]   ..$ mpg : num [1:32] 21 21 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 ...
[15:32:45.831]   ..$ cyl : num [1:32] 6 6 4 6 8 6 8 4 4 6 ...
[15:32:45.831]   ..$ disp: num [1:32] 160 160 108 258 360 ...
[15:32:45.831]   ..$ hp  : num [1:32] 110 110 93 110 175 105 245 62 95 123 ...
[15:32:45.831]   ..$ drat: num [1:32] 3.9 3.9 3.85 3.08 3.15 2.76 3.21 3.69 3.92 3.92 ...
[15:32:45.831]   ..$ wt  : num [1:32] 2.62 2.88 2.32 3.21 3.44 ...
[15:32:45.831]   ..$ qsec: num [1:32] 16.5 17 18.6 19.4 17 ...
[15:32:45.831]   ..$ vs  : num [1:32] 0 0 1 1 0 1 0 1 1 1 ...
[15:32:45.831]   ..$ am  : num [1:32] 1 1 1 0 0 0 0 0 0 0 ...
[15:32:45.831]   ..$ gear: num [1:32] 4 4 4 3 3 3 3 4 4 4 ...
[15:32:45.831]   ..$ carb: num [1:32] 4 4 1 1 2 1 4 2 2 4 ...
[15:32:45.831]  $ ...future.seeds_ii       : NULL
[15:32:45.831]  $ ...future.globals.maxSize: NULL
[15:32:45.831]  - attr(*, "where")=List of 11
[15:32:45.831]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:45.831]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:45.831]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:45.831]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:45.831]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:45.831]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:45.831]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:45.831]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:45.831]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:45.831]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:45.831]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:45.831]  - attr(*, "resolved")= logi FALSE
[15:32:45.831]  - attr(*, "total_size")= num 94200
[15:32:45.831]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.831]  - attr(*, "already-done")= logi TRUE
[15:32:45.858] - copied '...future.FUN' to environment
[15:32:45.858] - copied 'x_FUN' to environment
[15:32:45.859] - copied 'times' to environment
[15:32:45.859] - copied 'stopf' to environment
[15:32:45.859] - copied 'stop_if_not' to environment
[15:32:45.860] - copied 'dim' to environment
[15:32:45.860] - copied 'valid_types' to environment
[15:32:45.860] - copied 'future.call.arguments' to environment
[15:32:45.861] - copied '...future.elements_ii' to environment
[15:32:45.861] - copied '...future.seeds_ii' to environment
[15:32:45.861] - copied '...future.globals.maxSize' to environment
[15:32:45.861] assign_globals() ... done
[15:32:45.863] plan(): Setting new future strategy stack:
[15:32:45.863] List of future strategies:
[15:32:45.863] 1. sequential:
[15:32:45.863]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.863]    - tweaked: FALSE
[15:32:45.863]    - call: NULL
[15:32:45.864] plan(): nbrOfWorkers() = 1
[15:32:45.866] plan(): Setting new future strategy stack:
[15:32:45.866] List of future strategies:
[15:32:45.866] 1. sequential:
[15:32:45.866]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.866]    - tweaked: FALSE
[15:32:45.866]    - call: plan(strategy)
[15:32:45.867] plan(): nbrOfWorkers() = 1
[15:32:45.868] SequentialFuture started (and completed)
[15:32:45.868] - Launch lazy future ... done
[15:32:45.868] run() for 'SequentialFuture' ... done
[15:32:45.869] Created future:
[15:32:45.869] SequentialFuture:
[15:32:45.869] Label: 'future_vapply-1'
[15:32:45.869] Expression:
[15:32:45.869] {
[15:32:45.869]     do.call(function(...) {
[15:32:45.869]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.869]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.869]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.869]             on.exit(options(oopts), add = TRUE)
[15:32:45.869]         }
[15:32:45.869]         {
[15:32:45.869]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.869]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.869]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.869]             })
[15:32:45.869]         }
[15:32:45.869]     }, args = future.call.arguments)
[15:32:45.869] }
[15:32:45.869] Lazy evaluation: FALSE
[15:32:45.869] Asynchronous evaluation: FALSE
[15:32:45.869] Local evaluation: TRUE
[15:32:45.869] Environment: R_GlobalEnv
[15:32:45.869] Capture standard output: TRUE
[15:32:45.869] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:45.869] Globals: 11 objects totaling 95.26 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 56 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:45.869] Packages: 1 packages ('future.apply')
[15:32:45.869] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:45.869] Resolved: TRUE
[15:32:45.869] Value: 616 bytes of class 'list'
[15:32:45.869] Early signaling: FALSE
[15:32:45.869] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:45.869] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.872] Chunk #1 of 1 ... DONE
[15:32:45.872] Launching 1 futures (chunks) ... DONE
[15:32:45.872] Resolving 1 futures (chunks) ...
[15:32:45.872] resolve() on list ...
[15:32:45.873]  recursive: 0
[15:32:45.873]  length: 1
[15:32:45.873] 
[15:32:45.874] resolved() for 'SequentialFuture' ...
[15:32:45.874] - state: 'finished'
[15:32:45.874] - run: TRUE
[15:32:45.875] - result: 'FutureResult'
[15:32:45.875] resolved() for 'SequentialFuture' ... done
[15:32:45.875] Future #1
[15:32:45.876] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:45.876] - nx: 1
[15:32:45.876] - relay: TRUE
[15:32:45.876] - stdout: TRUE
[15:32:45.877] - signal: TRUE
[15:32:45.877] - resignal: FALSE
[15:32:45.877] - force: TRUE
[15:32:45.878] - relayed: [n=1] FALSE
[15:32:45.878] - queued futures: [n=1] FALSE
[15:32:45.878]  - until=1
[15:32:45.878]  - relaying element #1
[15:32:45.879] - relayed: [n=1] TRUE
[15:32:45.879] - queued futures: [n=1] TRUE
[15:32:45.879] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:45.880]  length: 0 (resolved future 1)
[15:32:45.880] Relaying remaining futures
[15:32:45.880] signalConditionsASAP(NULL, pos=0) ...
[15:32:45.881] - nx: 1
[15:32:45.881] - relay: TRUE
[15:32:45.881] - stdout: TRUE
[15:32:45.881] - signal: TRUE
[15:32:45.882] - resignal: FALSE
[15:32:45.882] - force: TRUE
[15:32:45.882] - relayed: [n=1] TRUE
[15:32:45.882] - queued futures: [n=1] TRUE
 - flush all
[15:32:45.883] - relayed: [n=1] TRUE
[15:32:45.883] - queued futures: [n=1] TRUE
[15:32:45.883] signalConditionsASAP(NULL, pos=0) ... done
[15:32:45.884] resolve() on list ... DONE
[15:32:45.884]  - Number of value chunks collected: 1
[15:32:45.884] Resolving 1 futures (chunks) ... DONE
[15:32:45.885] Reducing values from 1 chunks ...
[15:32:45.885]  - Number of values collected after concatenation: 11
[15:32:45.885]  - Number of values expected: 11
[15:32:45.886] Reducing values from 1 chunks ... DONE
[15:32:45.886] future_lapply() ... DONE
 Named logi [1:11] TRUE TRUE TRUE TRUE TRUE TRUE ...
 - attr(*, "names")= chr [1:11] "mpg" "cyl" "disp" "hp" ...
- future_vapply(x, ...) where length(x) != length(as.list(x)) ...
[15:32:45.888] future_lapply() ...
[15:32:45.895] Number of chunks: 1
[15:32:45.895] getGlobalsAndPackagesXApply() ...
[15:32:45.896]  - future.globals: TRUE
[15:32:45.896] getGlobalsAndPackages() ...
[15:32:45.896] Searching for globals...
[15:32:45.904] - globals found: [16] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types'
[15:32:45.904] Searching for globals ... DONE
[15:32:45.904] Resolving globals: FALSE
[15:32:45.907] The total size of the 7 globals is 92.05 KiB (94264 bytes)
[15:32:45.907] The total size of the 7 globals exported for future expression ('FUN()') is 92.05 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:45.908] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:45.908] - packages: [1] 'future.apply'
[15:32:45.908] getGlobalsAndPackages() ... DONE
[15:32:45.909]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:45.909]  - needed namespaces: [n=1] 'future.apply'
[15:32:45.909] Finding globals ... DONE
[15:32:45.910]  - use_args: TRUE
[15:32:45.910]  - Getting '...' globals ...
[15:32:45.911] resolve() on list ...
[15:32:45.911]  recursive: 0
[15:32:45.911]  length: 1
[15:32:45.911]  elements: '...'
[15:32:45.912]  length: 0 (resolved future 1)
[15:32:45.912] resolve() on list ... DONE
[15:32:45.912]    - '...' content: [n=0] 
[15:32:45.913] List of 1
[15:32:45.913]  $ ...: list()
[15:32:45.913]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.913]  - attr(*, "where")=List of 1
[15:32:45.913]   ..$ ...:<environment: 0x0000022d3e3445d8> 
[15:32:45.913]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.913]  - attr(*, "resolved")= logi TRUE
[15:32:45.913]  - attr(*, "total_size")= num NA
[15:32:45.918]  - Getting '...' globals ... DONE
[15:32:45.918] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:45.918] List of 8
[15:32:45.918]  $ ...future.FUN:function (x, ...)  
[15:32:45.918]  $ x_FUN        :function (x)  
[15:32:45.918]  $ times        : int 1
[15:32:45.918]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.918]  $ stop_if_not  :function (...)  
[15:32:45.918]  $ dim          : NULL
[15:32:45.918]  $ valid_types  : chr [1:2] "logical" "integer"
[15:32:45.918]  $ ...          : list()
[15:32:45.918]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.918]  - attr(*, "where")=List of 8
[15:32:45.918]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:45.918]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:45.918]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:45.918]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:45.918]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:45.918]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:45.918]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:45.918]   ..$ ...          :<environment: 0x0000022d3e3445d8> 
[15:32:45.918]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.918]  - attr(*, "resolved")= logi FALSE
[15:32:45.918]  - attr(*, "total_size")= num 94264
[15:32:45.933] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:45.933] getGlobalsAndPackagesXApply() ... DONE
[15:32:45.934] Number of futures (= number of chunks): 1
[15:32:45.934] Launching 1 futures (chunks) ...
[15:32:45.935] Chunk #1 of 1 ...
[15:32:45.935]  - Finding globals in 'X' for chunk #1 ...
[15:32:45.935] getGlobalsAndPackages() ...
[15:32:45.936] Searching for globals...
[15:32:45.936] 
[15:32:45.937] Searching for globals ... DONE
[15:32:45.937] - globals: [0] <none>
[15:32:45.937] getGlobalsAndPackages() ... DONE
[15:32:45.937]    + additional globals found: [n=0] 
[15:32:45.938]    + additional namespaces needed: [n=0] 
[15:32:45.938]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:45.938]  - seeds: <none>
[15:32:45.939]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.939] getGlobalsAndPackages() ...
[15:32:45.939] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.940] Resolving globals: FALSE
[15:32:45.940] Tweak future expression to call with '...' arguments ...
[15:32:45.941] {
[15:32:45.941]     do.call(function(...) {
[15:32:45.941]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.941]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.941]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.941]             on.exit(options(oopts), add = TRUE)
[15:32:45.941]         }
[15:32:45.941]         {
[15:32:45.941]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.941]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.941]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.941]             })
[15:32:45.941]         }
[15:32:45.941]     }, args = future.call.arguments)
[15:32:45.941] }
[15:32:45.941] Tweak future expression to call with '...' arguments ... DONE
[15:32:45.943] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:45.943] - packages: [1] 'future.apply'
[15:32:45.943] getGlobalsAndPackages() ... DONE
[15:32:45.944] run() for 'Future' ...
[15:32:45.944] - state: 'created'
[15:32:45.945] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:45.945] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.946] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:45.946]   - Field: 'label'
[15:32:45.946]   - Field: 'local'
[15:32:45.947]   - Field: 'owner'
[15:32:45.947]   - Field: 'envir'
[15:32:45.947]   - Field: 'packages'
[15:32:45.948]   - Field: 'gc'
[15:32:45.948]   - Field: 'conditions'
[15:32:45.948]   - Field: 'expr'
[15:32:45.948]   - Field: 'uuid'
[15:32:45.949]   - Field: 'seed'
[15:32:45.949]   - Field: 'version'
[15:32:45.949]   - Field: 'result'
[15:32:45.950]   - Field: 'asynchronous'
[15:32:45.950]   - Field: 'calls'
[15:32:45.950]   - Field: 'globals'
[15:32:45.951]   - Field: 'stdout'
[15:32:45.951]   - Field: 'earlySignal'
[15:32:45.951]   - Field: 'lazy'
[15:32:45.952]   - Field: 'state'
[15:32:45.952] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:45.952] - Launch lazy future ...
[15:32:45.953] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:45.953] Packages needed by future strategies (n = 0): <none>
[15:32:45.954] {
[15:32:45.954]     {
[15:32:45.954]         {
[15:32:45.954]             ...future.startTime <- base::Sys.time()
[15:32:45.954]             {
[15:32:45.954]                 {
[15:32:45.954]                   {
[15:32:45.954]                     {
[15:32:45.954]                       base::local({
[15:32:45.954]                         has_future <- base::requireNamespace("future", 
[15:32:45.954]                           quietly = TRUE)
[15:32:45.954]                         if (has_future) {
[15:32:45.954]                           ns <- base::getNamespace("future")
[15:32:45.954]                           version <- ns[[".package"]][["version"]]
[15:32:45.954]                           if (is.null(version)) 
[15:32:45.954]                             version <- utils::packageVersion("future")
[15:32:45.954]                         }
[15:32:45.954]                         else {
[15:32:45.954]                           version <- NULL
[15:32:45.954]                         }
[15:32:45.954]                         if (!has_future || version < "1.8.0") {
[15:32:45.954]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:45.954]                             "", base::R.version$version.string), 
[15:32:45.954]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:45.954]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:45.954]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:45.954]                               "release", "version")], collapse = " "), 
[15:32:45.954]                             hostname = base::Sys.info()[["nodename"]])
[15:32:45.954]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:45.954]                             info)
[15:32:45.954]                           info <- base::paste(info, collapse = "; ")
[15:32:45.954]                           if (!has_future) {
[15:32:45.954]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:45.954]                               info)
[15:32:45.954]                           }
[15:32:45.954]                           else {
[15:32:45.954]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:45.954]                               info, version)
[15:32:45.954]                           }
[15:32:45.954]                           base::stop(msg)
[15:32:45.954]                         }
[15:32:45.954]                       })
[15:32:45.954]                     }
[15:32:45.954]                     base::local({
[15:32:45.954]                       for (pkg in "future.apply") {
[15:32:45.954]                         base::loadNamespace(pkg)
[15:32:45.954]                         base::library(pkg, character.only = TRUE)
[15:32:45.954]                       }
[15:32:45.954]                     })
[15:32:45.954]                   }
[15:32:45.954]                   ...future.strategy.old <- future::plan("list")
[15:32:45.954]                   options(future.plan = NULL)
[15:32:45.954]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.954]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:45.954]                 }
[15:32:45.954]                 ...future.workdir <- getwd()
[15:32:45.954]             }
[15:32:45.954]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:45.954]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:45.954]         }
[15:32:45.954]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:45.954]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:45.954]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:45.954]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:45.954]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:45.954]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:45.954]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:45.954]             base::names(...future.oldOptions))
[15:32:45.954]     }
[15:32:45.954]     if (FALSE) {
[15:32:45.954]     }
[15:32:45.954]     else {
[15:32:45.954]         if (TRUE) {
[15:32:45.954]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:45.954]                 open = "w")
[15:32:45.954]         }
[15:32:45.954]         else {
[15:32:45.954]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:45.954]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:45.954]         }
[15:32:45.954]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:45.954]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:45.954]             base::sink(type = "output", split = FALSE)
[15:32:45.954]             base::close(...future.stdout)
[15:32:45.954]         }, add = TRUE)
[15:32:45.954]     }
[15:32:45.954]     ...future.frame <- base::sys.nframe()
[15:32:45.954]     ...future.conditions <- base::list()
[15:32:45.954]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:45.954]     if (FALSE) {
[15:32:45.954]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:45.954]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:45.954]     }
[15:32:45.954]     ...future.result <- base::tryCatch({
[15:32:45.954]         base::withCallingHandlers({
[15:32:45.954]             ...future.value <- base::withVisible(base::local({
[15:32:45.954]                 do.call(function(...) {
[15:32:45.954]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.954]                   if (!identical(...future.globals.maxSize.org, 
[15:32:45.954]                     ...future.globals.maxSize)) {
[15:32:45.954]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.954]                     on.exit(options(oopts), add = TRUE)
[15:32:45.954]                   }
[15:32:45.954]                   {
[15:32:45.954]                     lapply(seq_along(...future.elements_ii), 
[15:32:45.954]                       FUN = function(jj) {
[15:32:45.954]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.954]                         ...future.FUN(...future.X_jj, ...)
[15:32:45.954]                       })
[15:32:45.954]                   }
[15:32:45.954]                 }, args = future.call.arguments)
[15:32:45.954]             }))
[15:32:45.954]             future::FutureResult(value = ...future.value$value, 
[15:32:45.954]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.954]                   ...future.rng), globalenv = if (FALSE) 
[15:32:45.954]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:45.954]                     ...future.globalenv.names))
[15:32:45.954]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:45.954]         }, condition = base::local({
[15:32:45.954]             c <- base::c
[15:32:45.954]             inherits <- base::inherits
[15:32:45.954]             invokeRestart <- base::invokeRestart
[15:32:45.954]             length <- base::length
[15:32:45.954]             list <- base::list
[15:32:45.954]             seq.int <- base::seq.int
[15:32:45.954]             signalCondition <- base::signalCondition
[15:32:45.954]             sys.calls <- base::sys.calls
[15:32:45.954]             `[[` <- base::`[[`
[15:32:45.954]             `+` <- base::`+`
[15:32:45.954]             `<<-` <- base::`<<-`
[15:32:45.954]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:45.954]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:45.954]                   3L)]
[15:32:45.954]             }
[15:32:45.954]             function(cond) {
[15:32:45.954]                 is_error <- inherits(cond, "error")
[15:32:45.954]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:45.954]                   NULL)
[15:32:45.954]                 if (is_error) {
[15:32:45.954]                   sessionInformation <- function() {
[15:32:45.954]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:45.954]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:45.954]                       search = base::search(), system = base::Sys.info())
[15:32:45.954]                   }
[15:32:45.954]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.954]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:45.954]                     cond$call), session = sessionInformation(), 
[15:32:45.954]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:45.954]                   signalCondition(cond)
[15:32:45.954]                 }
[15:32:45.954]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:45.954]                 "immediateCondition"))) {
[15:32:45.954]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:45.954]                   ...future.conditions[[length(...future.conditions) + 
[15:32:45.954]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:45.954]                   if (TRUE && !signal) {
[15:32:45.954]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.954]                     {
[15:32:45.954]                       inherits <- base::inherits
[15:32:45.954]                       invokeRestart <- base::invokeRestart
[15:32:45.954]                       is.null <- base::is.null
[15:32:45.954]                       muffled <- FALSE
[15:32:45.954]                       if (inherits(cond, "message")) {
[15:32:45.954]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.954]                         if (muffled) 
[15:32:45.954]                           invokeRestart("muffleMessage")
[15:32:45.954]                       }
[15:32:45.954]                       else if (inherits(cond, "warning")) {
[15:32:45.954]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.954]                         if (muffled) 
[15:32:45.954]                           invokeRestart("muffleWarning")
[15:32:45.954]                       }
[15:32:45.954]                       else if (inherits(cond, "condition")) {
[15:32:45.954]                         if (!is.null(pattern)) {
[15:32:45.954]                           computeRestarts <- base::computeRestarts
[15:32:45.954]                           grepl <- base::grepl
[15:32:45.954]                           restarts <- computeRestarts(cond)
[15:32:45.954]                           for (restart in restarts) {
[15:32:45.954]                             name <- restart$name
[15:32:45.954]                             if (is.null(name)) 
[15:32:45.954]                               next
[15:32:45.954]                             if (!grepl(pattern, name)) 
[15:32:45.954]                               next
[15:32:45.954]                             invokeRestart(restart)
[15:32:45.954]                             muffled <- TRUE
[15:32:45.954]                             break
[15:32:45.954]                           }
[15:32:45.954]                         }
[15:32:45.954]                       }
[15:32:45.954]                       invisible(muffled)
[15:32:45.954]                     }
[15:32:45.954]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.954]                   }
[15:32:45.954]                 }
[15:32:45.954]                 else {
[15:32:45.954]                   if (TRUE) {
[15:32:45.954]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:45.954]                     {
[15:32:45.954]                       inherits <- base::inherits
[15:32:45.954]                       invokeRestart <- base::invokeRestart
[15:32:45.954]                       is.null <- base::is.null
[15:32:45.954]                       muffled <- FALSE
[15:32:45.954]                       if (inherits(cond, "message")) {
[15:32:45.954]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:45.954]                         if (muffled) 
[15:32:45.954]                           invokeRestart("muffleMessage")
[15:32:45.954]                       }
[15:32:45.954]                       else if (inherits(cond, "warning")) {
[15:32:45.954]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:45.954]                         if (muffled) 
[15:32:45.954]                           invokeRestart("muffleWarning")
[15:32:45.954]                       }
[15:32:45.954]                       else if (inherits(cond, "condition")) {
[15:32:45.954]                         if (!is.null(pattern)) {
[15:32:45.954]                           computeRestarts <- base::computeRestarts
[15:32:45.954]                           grepl <- base::grepl
[15:32:45.954]                           restarts <- computeRestarts(cond)
[15:32:45.954]                           for (restart in restarts) {
[15:32:45.954]                             name <- restart$name
[15:32:45.954]                             if (is.null(name)) 
[15:32:45.954]                               next
[15:32:45.954]                             if (!grepl(pattern, name)) 
[15:32:45.954]                               next
[15:32:45.954]                             invokeRestart(restart)
[15:32:45.954]                             muffled <- TRUE
[15:32:45.954]                             break
[15:32:45.954]                           }
[15:32:45.954]                         }
[15:32:45.954]                       }
[15:32:45.954]                       invisible(muffled)
[15:32:45.954]                     }
[15:32:45.954]                     muffleCondition(cond, pattern = "^muffle")
[15:32:45.954]                   }
[15:32:45.954]                 }
[15:32:45.954]             }
[15:32:45.954]         }))
[15:32:45.954]     }, error = function(ex) {
[15:32:45.954]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:45.954]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:45.954]                 ...future.rng), started = ...future.startTime, 
[15:32:45.954]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:45.954]             version = "1.8"), class = "FutureResult")
[15:32:45.954]     }, finally = {
[15:32:45.954]         if (!identical(...future.workdir, getwd())) 
[15:32:45.954]             setwd(...future.workdir)
[15:32:45.954]         {
[15:32:45.954]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:45.954]                 ...future.oldOptions$nwarnings <- NULL
[15:32:45.954]             }
[15:32:45.954]             base::options(...future.oldOptions)
[15:32:45.954]             if (.Platform$OS.type == "windows") {
[15:32:45.954]                 old_names <- names(...future.oldEnvVars)
[15:32:45.954]                 envs <- base::Sys.getenv()
[15:32:45.954]                 names <- names(envs)
[15:32:45.954]                 common <- intersect(names, old_names)
[15:32:45.954]                 added <- setdiff(names, old_names)
[15:32:45.954]                 removed <- setdiff(old_names, names)
[15:32:45.954]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:45.954]                   envs[common]]
[15:32:45.954]                 NAMES <- toupper(changed)
[15:32:45.954]                 args <- list()
[15:32:45.954]                 for (kk in seq_along(NAMES)) {
[15:32:45.954]                   name <- changed[[kk]]
[15:32:45.954]                   NAME <- NAMES[[kk]]
[15:32:45.954]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.954]                     next
[15:32:45.954]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.954]                 }
[15:32:45.954]                 NAMES <- toupper(added)
[15:32:45.954]                 for (kk in seq_along(NAMES)) {
[15:32:45.954]                   name <- added[[kk]]
[15:32:45.954]                   NAME <- NAMES[[kk]]
[15:32:45.954]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.954]                     next
[15:32:45.954]                   args[[name]] <- ""
[15:32:45.954]                 }
[15:32:45.954]                 NAMES <- toupper(removed)
[15:32:45.954]                 for (kk in seq_along(NAMES)) {
[15:32:45.954]                   name <- removed[[kk]]
[15:32:45.954]                   NAME <- NAMES[[kk]]
[15:32:45.954]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:45.954]                     next
[15:32:45.954]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:45.954]                 }
[15:32:45.954]                 if (length(args) > 0) 
[15:32:45.954]                   base::do.call(base::Sys.setenv, args = args)
[15:32:45.954]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:45.954]             }
[15:32:45.954]             else {
[15:32:45.954]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:45.954]             }
[15:32:45.954]             {
[15:32:45.954]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:45.954]                   0L) {
[15:32:45.954]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:45.954]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:45.954]                   base::options(opts)
[15:32:45.954]                 }
[15:32:45.954]                 {
[15:32:45.954]                   {
[15:32:45.954]                     NULL
[15:32:45.954]                     RNGkind("Mersenne-Twister")
[15:32:45.954]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:45.954]                       inherits = FALSE)
[15:32:45.954]                   }
[15:32:45.954]                   options(future.plan = NULL)
[15:32:45.954]                   if (is.na(NA_character_)) 
[15:32:45.954]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:45.954]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:45.954]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:45.954]                     .init = FALSE)
[15:32:45.954]                 }
[15:32:45.954]             }
[15:32:45.954]         }
[15:32:45.954]     })
[15:32:45.954]     if (TRUE) {
[15:32:45.954]         base::sink(type = "output", split = FALSE)
[15:32:45.954]         if (TRUE) {
[15:32:45.954]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:45.954]         }
[15:32:45.954]         else {
[15:32:45.954]             ...future.result["stdout"] <- base::list(NULL)
[15:32:45.954]         }
[15:32:45.954]         base::close(...future.stdout)
[15:32:45.954]         ...future.stdout <- NULL
[15:32:45.954]     }
[15:32:45.954]     ...future.result$conditions <- ...future.conditions
[15:32:45.954]     ...future.result$finished <- base::Sys.time()
[15:32:45.954]     ...future.result
[15:32:45.954] }
[15:32:45.961] assign_globals() ...
[15:32:45.962] List of 11
[15:32:45.962]  $ ...future.FUN            :function (x, ...)  
[15:32:45.962]  $ x_FUN                    :function (x)  
[15:32:45.962]  $ times                    : int 1
[15:32:45.962]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:45.962]  $ stop_if_not              :function (...)  
[15:32:45.962]  $ dim                      : NULL
[15:32:45.962]  $ valid_types              : chr [1:2] "logical" "integer"
[15:32:45.962]  $ future.call.arguments    : list()
[15:32:45.962]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:45.962]  $ ...future.elements_ii    :List of 3
[15:32:45.962]   ..$ a: num 1
[15:32:45.962]   ..$ b: num 2
[15:32:45.962]   ..$ c: num 3
[15:32:45.962]  $ ...future.seeds_ii       : NULL
[15:32:45.962]  $ ...future.globals.maxSize: NULL
[15:32:45.962]  - attr(*, "where")=List of 11
[15:32:45.962]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:45.962]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:45.962]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:45.962]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:45.962]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:45.962]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:45.962]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:45.962]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:45.962]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:45.962]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:45.962]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:45.962]  - attr(*, "resolved")= logi FALSE
[15:32:45.962]  - attr(*, "total_size")= num 94264
[15:32:45.962]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:45.962]  - attr(*, "already-done")= logi TRUE
[15:32:45.982] - copied '...future.FUN' to environment
[15:32:45.982] - copied 'x_FUN' to environment
[15:32:45.982] - copied 'times' to environment
[15:32:45.983] - copied 'stopf' to environment
[15:32:45.983] - copied 'stop_if_not' to environment
[15:32:45.983] - copied 'dim' to environment
[15:32:45.984] - copied 'valid_types' to environment
[15:32:45.984] - copied 'future.call.arguments' to environment
[15:32:45.984] - copied '...future.elements_ii' to environment
[15:32:45.985] - copied '...future.seeds_ii' to environment
[15:32:45.985] - copied '...future.globals.maxSize' to environment
[15:32:45.985] assign_globals() ... done
[15:32:45.986] plan(): Setting new future strategy stack:
[15:32:45.987] List of future strategies:
[15:32:45.987] 1. sequential:
[15:32:45.987]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.987]    - tweaked: FALSE
[15:32:45.987]    - call: NULL
[15:32:45.988] plan(): nbrOfWorkers() = 1
[15:32:45.990] plan(): Setting new future strategy stack:
[15:32:45.990] List of future strategies:
[15:32:45.990] 1. sequential:
[15:32:45.990]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:45.990]    - tweaked: FALSE
[15:32:45.990]    - call: plan(strategy)
[15:32:45.991] plan(): nbrOfWorkers() = 1
[15:32:45.992] SequentialFuture started (and completed)
[15:32:45.992] - Launch lazy future ... done
[15:32:45.992] run() for 'SequentialFuture' ... done
[15:32:45.993] Created future:
[15:32:45.993] SequentialFuture:
[15:32:45.993] Label: 'future_vapply-1'
[15:32:45.993] Expression:
[15:32:45.993] {
[15:32:45.993]     do.call(function(...) {
[15:32:45.993]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:45.993]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:45.993]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:45.993]             on.exit(options(oopts), add = TRUE)
[15:32:45.993]         }
[15:32:45.993]         {
[15:32:45.993]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:45.993]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:45.993]                 ...future.FUN(...future.X_jj, ...)
[15:32:45.993]             })
[15:32:45.993]         }
[15:32:45.993]     }, args = future.call.arguments)
[15:32:45.993] }
[15:32:45.993] Lazy evaluation: FALSE
[15:32:45.993] Asynchronous evaluation: FALSE
[15:32:45.993] Local evaluation: TRUE
[15:32:45.993] Environment: R_GlobalEnv
[15:32:45.993] Capture standard output: TRUE
[15:32:45.993] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:45.993] Globals: 11 objects totaling 92.22 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 56 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:45.993] Packages: 1 packages ('future.apply')
[15:32:45.993] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:45.993] Resolved: TRUE
[15:32:45.993] Value: 168 bytes of class 'list'
[15:32:45.993] Early signaling: FALSE
[15:32:45.993] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:45.993] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:45.996] Chunk #1 of 1 ... DONE
[15:32:45.996] Launching 1 futures (chunks) ... DONE
[15:32:45.996] Resolving 1 futures (chunks) ...
[15:32:45.997] resolve() on list ...
[15:32:45.997]  recursive: 0
[15:32:45.997]  length: 1
[15:32:45.997] 
[15:32:45.997] resolved() for 'SequentialFuture' ...
[15:32:45.998] - state: 'finished'
[15:32:45.998] - run: TRUE
[15:32:45.998] - result: 'FutureResult'
[15:32:45.998] resolved() for 'SequentialFuture' ... done
[15:32:45.998] Future #1
[15:32:45.999] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:45.999] - nx: 1
[15:32:45.999] - relay: TRUE
[15:32:45.999] - stdout: TRUE
[15:32:46.000] - signal: TRUE
[15:32:46.000] - resignal: FALSE
[15:32:46.000] - force: TRUE
[15:32:46.001] - relayed: [n=1] FALSE
[15:32:46.001] - queued futures: [n=1] FALSE
[15:32:46.001]  - until=1
[15:32:46.001]  - relaying element #1
[15:32:46.002] - relayed: [n=1] TRUE
[15:32:46.002] - queued futures: [n=1] TRUE
[15:32:46.003] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:46.003]  length: 0 (resolved future 1)
[15:32:46.003] Relaying remaining futures
[15:32:46.003] signalConditionsASAP(NULL, pos=0) ...
[15:32:46.004] - nx: 1
[15:32:46.004] - relay: TRUE
[15:32:46.004] - stdout: TRUE
[15:32:46.005] - signal: TRUE
[15:32:46.005] - resignal: FALSE
[15:32:46.005] - force: TRUE
[15:32:46.005] - relayed: [n=1] TRUE
[15:32:46.006] - queued futures: [n=1] TRUE
 - flush all
[15:32:46.006] - relayed: [n=1] TRUE
[15:32:46.007] - queued futures: [n=1] TRUE
[15:32:46.007] signalConditionsASAP(NULL, pos=0) ... done
[15:32:46.007] resolve() on list ... DONE
[15:32:46.008]  - Number of value chunks collected: 1
[15:32:46.008] Resolving 1 futures (chunks) ... DONE
[15:32:46.008] Reducing values from 1 chunks ...
[15:32:46.009]  - Number of values collected after concatenation: 3
[15:32:46.009]  - Number of values expected: 3
[15:32:46.009] Reducing values from 1 chunks ... DONE
[15:32:46.010] future_lapply() ... DONE
- exceptions ...
[15:32:46.010] future_lapply() ...
[15:32:46.015] Number of chunks: 1
[15:32:46.015] getGlobalsAndPackagesXApply() ...
[15:32:46.015]  - future.globals: TRUE
[15:32:46.016] getGlobalsAndPackages() ...
[15:32:46.016] Searching for globals...
[15:32:46.027] - globals found: [16] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types'
[15:32:46.027] Searching for globals ... DONE
[15:32:46.028] Resolving globals: FALSE
[15:32:46.030] The total size of the 7 globals is 92.90 KiB (95128 bytes)
[15:32:46.031] The total size of the 7 globals exported for future expression ('FUN()') is 92.90 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:46.031] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:46.031] - packages: [1] 'future.apply'
[15:32:46.032] getGlobalsAndPackages() ... DONE
[15:32:46.032]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:46.032]  - needed namespaces: [n=1] 'future.apply'
[15:32:46.033] Finding globals ... DONE
[15:32:46.033]  - use_args: TRUE
[15:32:46.033]  - Getting '...' globals ...
[15:32:46.034] resolve() on list ...
[15:32:46.035]  recursive: 0
[15:32:46.035]  length: 1
[15:32:46.035]  elements: '...'
[15:32:46.036]  length: 0 (resolved future 1)
[15:32:46.036] resolve() on list ... DONE
[15:32:46.036]    - '...' content: [n=0] 
[15:32:46.037] List of 1
[15:32:46.037]  $ ...: list()
[15:32:46.037]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:46.037]  - attr(*, "where")=List of 1
[15:32:46.037]   ..$ ...:<environment: 0x0000022d3c7d6538> 
[15:32:46.037]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:46.037]  - attr(*, "resolved")= logi TRUE
[15:32:46.037]  - attr(*, "total_size")= num NA
[15:32:46.042]  - Getting '...' globals ... DONE
[15:32:46.042] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:46.043] List of 8
[15:32:46.043]  $ ...future.FUN:function (x, ...)  
[15:32:46.043]  $ x_FUN        :function (x)  
[15:32:46.043]  $ times        : int 2
[15:32:46.043]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:46.043]  $ stop_if_not  :function (...)  
[15:32:46.043]  $ dim          : NULL
[15:32:46.043]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:46.043]  $ ...          : list()
[15:32:46.043]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:46.043]  - attr(*, "where")=List of 8
[15:32:46.043]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:46.043]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:46.043]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:46.043]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:46.043]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:46.043]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:46.043]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:46.043]   ..$ ...          :<environment: 0x0000022d3c7d6538> 
[15:32:46.043]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:46.043]  - attr(*, "resolved")= logi FALSE
[15:32:46.043]  - attr(*, "total_size")= num 95128
[15:32:46.055] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:46.055] getGlobalsAndPackagesXApply() ... DONE
[15:32:46.056] Number of futures (= number of chunks): 1
[15:32:46.056] Launching 1 futures (chunks) ...
[15:32:46.056] Chunk #1 of 1 ...
[15:32:46.057]  - Finding globals in 'X' for chunk #1 ...
[15:32:46.057] getGlobalsAndPackages() ...
[15:32:46.057] Searching for globals...
[15:32:46.058] 
[15:32:46.058] Searching for globals ... DONE
[15:32:46.058] - globals: [0] <none>
[15:32:46.059] getGlobalsAndPackages() ... DONE
[15:32:46.059]    + additional globals found: [n=0] 
[15:32:46.059]    + additional namespaces needed: [n=0] 
[15:32:46.059]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:46.060]  - seeds: <none>
[15:32:46.060]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:46.060] getGlobalsAndPackages() ...
[15:32:46.061] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:46.061] Resolving globals: FALSE
[15:32:46.061] Tweak future expression to call with '...' arguments ...
[15:32:46.062] {
[15:32:46.062]     do.call(function(...) {
[15:32:46.062]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:46.062]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:46.062]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:46.062]             on.exit(options(oopts), add = TRUE)
[15:32:46.062]         }
[15:32:46.062]         {
[15:32:46.062]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:46.062]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:46.062]                 ...future.FUN(...future.X_jj, ...)
[15:32:46.062]             })
[15:32:46.062]         }
[15:32:46.062]     }, args = future.call.arguments)
[15:32:46.062] }
[15:32:46.065] Tweak future expression to call with '...' arguments ... DONE
[15:32:46.066] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:46.067] - packages: [1] 'future.apply'
[15:32:46.067] getGlobalsAndPackages() ... DONE
[15:32:46.068] run() for 'Future' ...
[15:32:46.068] - state: 'created'
[15:32:46.069] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:32:46.069] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:46.070] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:32:46.070]   - Field: 'label'
[15:32:46.070]   - Field: 'local'
[15:32:46.071]   - Field: 'owner'
[15:32:46.071]   - Field: 'envir'
[15:32:46.071]   - Field: 'packages'
[15:32:46.072]   - Field: 'gc'
[15:32:46.072]   - Field: 'conditions'
[15:32:46.072]   - Field: 'expr'
[15:32:46.073]   - Field: 'uuid'
[15:32:46.073]   - Field: 'seed'
[15:32:46.073]   - Field: 'version'
[15:32:46.074]   - Field: 'result'
[15:32:46.074]   - Field: 'asynchronous'
[15:32:46.075]   - Field: 'calls'
[15:32:46.075]   - Field: 'globals'
[15:32:46.075]   - Field: 'stdout'
[15:32:46.076]   - Field: 'earlySignal'
[15:32:46.076]   - Field: 'lazy'
[15:32:46.076]   - Field: 'state'
[15:32:46.077] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:32:46.077] - Launch lazy future ...
[15:32:46.078] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:46.078] Packages needed by future strategies (n = 0): <none>
[15:32:46.079] {
[15:32:46.079]     {
[15:32:46.079]         {
[15:32:46.079]             ...future.startTime <- base::Sys.time()
[15:32:46.079]             {
[15:32:46.079]                 {
[15:32:46.079]                   {
[15:32:46.079]                     {
[15:32:46.079]                       base::local({
[15:32:46.079]                         has_future <- base::requireNamespace("future", 
[15:32:46.079]                           quietly = TRUE)
[15:32:46.079]                         if (has_future) {
[15:32:46.079]                           ns <- base::getNamespace("future")
[15:32:46.079]                           version <- ns[[".package"]][["version"]]
[15:32:46.079]                           if (is.null(version)) 
[15:32:46.079]                             version <- utils::packageVersion("future")
[15:32:46.079]                         }
[15:32:46.079]                         else {
[15:32:46.079]                           version <- NULL
[15:32:46.079]                         }
[15:32:46.079]                         if (!has_future || version < "1.8.0") {
[15:32:46.079]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:46.079]                             "", base::R.version$version.string), 
[15:32:46.079]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:46.079]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:46.079]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:46.079]                               "release", "version")], collapse = " "), 
[15:32:46.079]                             hostname = base::Sys.info()[["nodename"]])
[15:32:46.079]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:46.079]                             info)
[15:32:46.079]                           info <- base::paste(info, collapse = "; ")
[15:32:46.079]                           if (!has_future) {
[15:32:46.079]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:46.079]                               info)
[15:32:46.079]                           }
[15:32:46.079]                           else {
[15:32:46.079]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:46.079]                               info, version)
[15:32:46.079]                           }
[15:32:46.079]                           base::stop(msg)
[15:32:46.079]                         }
[15:32:46.079]                       })
[15:32:46.079]                     }
[15:32:46.079]                     base::local({
[15:32:46.079]                       for (pkg in "future.apply") {
[15:32:46.079]                         base::loadNamespace(pkg)
[15:32:46.079]                         base::library(pkg, character.only = TRUE)
[15:32:46.079]                       }
[15:32:46.079]                     })
[15:32:46.079]                   }
[15:32:46.079]                   ...future.strategy.old <- future::plan("list")
[15:32:46.079]                   options(future.plan = NULL)
[15:32:46.079]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:46.079]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:46.079]                 }
[15:32:46.079]                 ...future.workdir <- getwd()
[15:32:46.079]             }
[15:32:46.079]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:46.079]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:46.079]         }
[15:32:46.079]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:46.079]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:46.079]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:46.079]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:46.079]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:46.079]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:46.079]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:46.079]             base::names(...future.oldOptions))
[15:32:46.079]     }
[15:32:46.079]     if (FALSE) {
[15:32:46.079]     }
[15:32:46.079]     else {
[15:32:46.079]         if (TRUE) {
[15:32:46.079]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:46.079]                 open = "w")
[15:32:46.079]         }
[15:32:46.079]         else {
[15:32:46.079]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:46.079]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:46.079]         }
[15:32:46.079]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:46.079]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:46.079]             base::sink(type = "output", split = FALSE)
[15:32:46.079]             base::close(...future.stdout)
[15:32:46.079]         }, add = TRUE)
[15:32:46.079]     }
[15:32:46.079]     ...future.frame <- base::sys.nframe()
[15:32:46.079]     ...future.conditions <- base::list()
[15:32:46.079]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:46.079]     if (FALSE) {
[15:32:46.079]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:46.079]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:46.079]     }
[15:32:46.079]     ...future.result <- base::tryCatch({
[15:32:46.079]         base::withCallingHandlers({
[15:32:46.079]             ...future.value <- base::withVisible(base::local({
[15:32:46.079]                 do.call(function(...) {
[15:32:46.079]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:46.079]                   if (!identical(...future.globals.maxSize.org, 
[15:32:46.079]                     ...future.globals.maxSize)) {
[15:32:46.079]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:46.079]                     on.exit(options(oopts), add = TRUE)
[15:32:46.079]                   }
[15:32:46.079]                   {
[15:32:46.079]                     lapply(seq_along(...future.elements_ii), 
[15:32:46.079]                       FUN = function(jj) {
[15:32:46.079]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:46.079]                         ...future.FUN(...future.X_jj, ...)
[15:32:46.079]                       })
[15:32:46.079]                   }
[15:32:46.079]                 }, args = future.call.arguments)
[15:32:46.079]             }))
[15:32:46.079]             future::FutureResult(value = ...future.value$value, 
[15:32:46.079]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:46.079]                   ...future.rng), globalenv = if (FALSE) 
[15:32:46.079]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:46.079]                     ...future.globalenv.names))
[15:32:46.079]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:46.079]         }, condition = base::local({
[15:32:46.079]             c <- base::c
[15:32:46.079]             inherits <- base::inherits
[15:32:46.079]             invokeRestart <- base::invokeRestart
[15:32:46.079]             length <- base::length
[15:32:46.079]             list <- base::list
[15:32:46.079]             seq.int <- base::seq.int
[15:32:46.079]             signalCondition <- base::signalCondition
[15:32:46.079]             sys.calls <- base::sys.calls
[15:32:46.079]             `[[` <- base::`[[`
[15:32:46.079]             `+` <- base::`+`
[15:32:46.079]             `<<-` <- base::`<<-`
[15:32:46.079]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:46.079]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:46.079]                   3L)]
[15:32:46.079]             }
[15:32:46.079]             function(cond) {
[15:32:46.079]                 is_error <- inherits(cond, "error")
[15:32:46.079]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:46.079]                   NULL)
[15:32:46.079]                 if (is_error) {
[15:32:46.079]                   sessionInformation <- function() {
[15:32:46.079]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:46.079]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:46.079]                       search = base::search(), system = base::Sys.info())
[15:32:46.079]                   }
[15:32:46.079]                   ...future.conditions[[length(...future.conditions) + 
[15:32:46.079]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:46.079]                     cond$call), session = sessionInformation(), 
[15:32:46.079]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:46.079]                   signalCondition(cond)
[15:32:46.079]                 }
[15:32:46.079]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:46.079]                 "immediateCondition"))) {
[15:32:46.079]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:46.079]                   ...future.conditions[[length(...future.conditions) + 
[15:32:46.079]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:46.079]                   if (TRUE && !signal) {
[15:32:46.079]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:46.079]                     {
[15:32:46.079]                       inherits <- base::inherits
[15:32:46.079]                       invokeRestart <- base::invokeRestart
[15:32:46.079]                       is.null <- base::is.null
[15:32:46.079]                       muffled <- FALSE
[15:32:46.079]                       if (inherits(cond, "message")) {
[15:32:46.079]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:46.079]                         if (muffled) 
[15:32:46.079]                           invokeRestart("muffleMessage")
[15:32:46.079]                       }
[15:32:46.079]                       else if (inherits(cond, "warning")) {
[15:32:46.079]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:46.079]                         if (muffled) 
[15:32:46.079]                           invokeRestart("muffleWarning")
[15:32:46.079]                       }
[15:32:46.079]                       else if (inherits(cond, "condition")) {
[15:32:46.079]                         if (!is.null(pattern)) {
[15:32:46.079]                           computeRestarts <- base::computeRestarts
[15:32:46.079]                           grepl <- base::grepl
[15:32:46.079]                           restarts <- computeRestarts(cond)
[15:32:46.079]                           for (restart in restarts) {
[15:32:46.079]                             name <- restart$name
[15:32:46.079]                             if (is.null(name)) 
[15:32:46.079]                               next
[15:32:46.079]                             if (!grepl(pattern, name)) 
[15:32:46.079]                               next
[15:32:46.079]                             invokeRestart(restart)
[15:32:46.079]                             muffled <- TRUE
[15:32:46.079]                             break
[15:32:46.079]                           }
[15:32:46.079]                         }
[15:32:46.079]                       }
[15:32:46.079]                       invisible(muffled)
[15:32:46.079]                     }
[15:32:46.079]                     muffleCondition(cond, pattern = "^muffle")
[15:32:46.079]                   }
[15:32:46.079]                 }
[15:32:46.079]                 else {
[15:32:46.079]                   if (TRUE) {
[15:32:46.079]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:46.079]                     {
[15:32:46.079]                       inherits <- base::inherits
[15:32:46.079]                       invokeRestart <- base::invokeRestart
[15:32:46.079]                       is.null <- base::is.null
[15:32:46.079]                       muffled <- FALSE
[15:32:46.079]                       if (inherits(cond, "message")) {
[15:32:46.079]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:46.079]                         if (muffled) 
[15:32:46.079]                           invokeRestart("muffleMessage")
[15:32:46.079]                       }
[15:32:46.079]                       else if (inherits(cond, "warning")) {
[15:32:46.079]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:46.079]                         if (muffled) 
[15:32:46.079]                           invokeRestart("muffleWarning")
[15:32:46.079]                       }
[15:32:46.079]                       else if (inherits(cond, "condition")) {
[15:32:46.079]                         if (!is.null(pattern)) {
[15:32:46.079]                           computeRestarts <- base::computeRestarts
[15:32:46.079]                           grepl <- base::grepl
[15:32:46.079]                           restarts <- computeRestarts(cond)
[15:32:46.079]                           for (restart in restarts) {
[15:32:46.079]                             name <- restart$name
[15:32:46.079]                             if (is.null(name)) 
[15:32:46.079]                               next
[15:32:46.079]                             if (!grepl(pattern, name)) 
[15:32:46.079]                               next
[15:32:46.079]                             invokeRestart(restart)
[15:32:46.079]                             muffled <- TRUE
[15:32:46.079]                             break
[15:32:46.079]                           }
[15:32:46.079]                         }
[15:32:46.079]                       }
[15:32:46.079]                       invisible(muffled)
[15:32:46.079]                     }
[15:32:46.079]                     muffleCondition(cond, pattern = "^muffle")
[15:32:46.079]                   }
[15:32:46.079]                 }
[15:32:46.079]             }
[15:32:46.079]         }))
[15:32:46.079]     }, error = function(ex) {
[15:32:46.079]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:46.079]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:46.079]                 ...future.rng), started = ...future.startTime, 
[15:32:46.079]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:46.079]             version = "1.8"), class = "FutureResult")
[15:32:46.079]     }, finally = {
[15:32:46.079]         if (!identical(...future.workdir, getwd())) 
[15:32:46.079]             setwd(...future.workdir)
[15:32:46.079]         {
[15:32:46.079]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:46.079]                 ...future.oldOptions$nwarnings <- NULL
[15:32:46.079]             }
[15:32:46.079]             base::options(...future.oldOptions)
[15:32:46.079]             if (.Platform$OS.type == "windows") {
[15:32:46.079]                 old_names <- names(...future.oldEnvVars)
[15:32:46.079]                 envs <- base::Sys.getenv()
[15:32:46.079]                 names <- names(envs)
[15:32:46.079]                 common <- intersect(names, old_names)
[15:32:46.079]                 added <- setdiff(names, old_names)
[15:32:46.079]                 removed <- setdiff(old_names, names)
[15:32:46.079]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:46.079]                   envs[common]]
[15:32:46.079]                 NAMES <- toupper(changed)
[15:32:46.079]                 args <- list()
[15:32:46.079]                 for (kk in seq_along(NAMES)) {
[15:32:46.079]                   name <- changed[[kk]]
[15:32:46.079]                   NAME <- NAMES[[kk]]
[15:32:46.079]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:46.079]                     next
[15:32:46.079]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:46.079]                 }
[15:32:46.079]                 NAMES <- toupper(added)
[15:32:46.079]                 for (kk in seq_along(NAMES)) {
[15:32:46.079]                   name <- added[[kk]]
[15:32:46.079]                   NAME <- NAMES[[kk]]
[15:32:46.079]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:46.079]                     next
[15:32:46.079]                   args[[name]] <- ""
[15:32:46.079]                 }
[15:32:46.079]                 NAMES <- toupper(removed)
[15:32:46.079]                 for (kk in seq_along(NAMES)) {
[15:32:46.079]                   name <- removed[[kk]]
[15:32:46.079]                   NAME <- NAMES[[kk]]
[15:32:46.079]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:46.079]                     next
[15:32:46.079]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:46.079]                 }
[15:32:46.079]                 if (length(args) > 0) 
[15:32:46.079]                   base::do.call(base::Sys.setenv, args = args)
[15:32:46.079]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:46.079]             }
[15:32:46.079]             else {
[15:32:46.079]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:46.079]             }
[15:32:46.079]             {
[15:32:46.079]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:46.079]                   0L) {
[15:32:46.079]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:46.079]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:46.079]                   base::options(opts)
[15:32:46.079]                 }
[15:32:46.079]                 {
[15:32:46.079]                   {
[15:32:46.079]                     NULL
[15:32:46.079]                     RNGkind("Mersenne-Twister")
[15:32:46.079]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:32:46.079]                       inherits = FALSE)
[15:32:46.079]                   }
[15:32:46.079]                   options(future.plan = NULL)
[15:32:46.079]                   if (is.na(NA_character_)) 
[15:32:46.079]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:46.079]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:46.079]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:46.079]                     .init = FALSE)
[15:32:46.079]                 }
[15:32:46.079]             }
[15:32:46.079]         }
[15:32:46.079]     })
[15:32:46.079]     if (TRUE) {
[15:32:46.079]         base::sink(type = "output", split = FALSE)
[15:32:46.079]         if (TRUE) {
[15:32:46.079]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:46.079]         }
[15:32:46.079]         else {
[15:32:46.079]             ...future.result["stdout"] <- base::list(NULL)
[15:32:46.079]         }
[15:32:46.079]         base::close(...future.stdout)
[15:32:46.079]         ...future.stdout <- NULL
[15:32:46.079]     }
[15:32:46.079]     ...future.result$conditions <- ...future.conditions
[15:32:46.079]     ...future.result$finished <- base::Sys.time()
[15:32:46.079]     ...future.result
[15:32:46.079] }
[15:32:46.086] assign_globals() ...
[15:32:46.087] List of 11
[15:32:46.087]  $ ...future.FUN            :function (x, ...)  
[15:32:46.087]  $ x_FUN                    :function (x)  
[15:32:46.087]  $ times                    : int 2
[15:32:46.087]  $ stopf                    :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:46.087]  $ stop_if_not              :function (...)  
[15:32:46.087]  $ dim                      : NULL
[15:32:46.087]  $ valid_types              : chr [1:3] "logical" "integer" "double"
[15:32:46.087]  $ future.call.arguments    : list()
[15:32:46.087]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:46.087]  $ ...future.elements_ii    :List of 3
[15:32:46.087]   ..$ : int 1
[15:32:46.087]   ..$ : int 2
[15:32:46.087]   ..$ : int 3
[15:32:46.087]  $ ...future.seeds_ii       : NULL
[15:32:46.087]  $ ...future.globals.maxSize: NULL
[15:32:46.087]  - attr(*, "where")=List of 11
[15:32:46.087]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:32:46.087]   ..$ x_FUN                    :<environment: R_EmptyEnv> 
[15:32:46.087]   ..$ times                    :<environment: R_EmptyEnv> 
[15:32:46.087]   ..$ stopf                    :<environment: R_EmptyEnv> 
[15:32:46.087]   ..$ stop_if_not              :<environment: R_EmptyEnv> 
[15:32:46.087]   ..$ dim                      :<environment: R_EmptyEnv> 
[15:32:46.087]   ..$ valid_types              :<environment: R_EmptyEnv> 
[15:32:46.087]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:32:46.087]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:32:46.087]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:32:46.087]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:32:46.087]  - attr(*, "resolved")= logi FALSE
[15:32:46.087]  - attr(*, "total_size")= num 95128
[15:32:46.087]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:46.087]  - attr(*, "already-done")= logi TRUE
[15:32:46.103] - copied '...future.FUN' to environment
[15:32:46.103] - copied 'x_FUN' to environment
[15:32:46.104] - copied 'times' to environment
[15:32:46.104] - copied 'stopf' to environment
[15:32:46.104] - copied 'stop_if_not' to environment
[15:32:46.105] - copied 'dim' to environment
[15:32:46.105] - copied 'valid_types' to environment
[15:32:46.105] - copied 'future.call.arguments' to environment
[15:32:46.105] - copied '...future.elements_ii' to environment
[15:32:46.106] - copied '...future.seeds_ii' to environment
[15:32:46.106] - copied '...future.globals.maxSize' to environment
[15:32:46.106] assign_globals() ... done
[15:32:46.107] plan(): Setting new future strategy stack:
[15:32:46.108] List of future strategies:
[15:32:46.108] 1. sequential:
[15:32:46.108]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:46.108]    - tweaked: FALSE
[15:32:46.108]    - call: NULL
[15:32:46.109] plan(): nbrOfWorkers() = 1
[15:32:46.114] plan(): Setting new future strategy stack:
[15:32:46.114] List of future strategies:
[15:32:46.114] 1. sequential:
[15:32:46.114]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:46.114]    - tweaked: FALSE
[15:32:46.114]    - call: plan(strategy)
[15:32:46.115] plan(): nbrOfWorkers() = 1
[15:32:46.116] SequentialFuture started (and completed)
[15:32:46.116] signalConditions() ...
[15:32:46.116]  - include = 'immediateCondition'
[15:32:46.117]  - exclude = 
[15:32:46.117]  - resignal = FALSE
[15:32:46.117]  - Number of conditions: 1
[15:32:46.118] signalConditions() ... done
[15:32:46.118] - Launch lazy future ... done
[15:32:46.118] run() for 'SequentialFuture' ... done
[15:32:46.118] Created future:
[15:32:46.119] SequentialFuture:
[15:32:46.119] Label: 'future_vapply-1'
[15:32:46.119] Expression:
[15:32:46.119] {
[15:32:46.119]     do.call(function(...) {
[15:32:46.119]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:46.119]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:46.119]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:46.119]             on.exit(options(oopts), add = TRUE)
[15:32:46.119]         }
[15:32:46.119]         {
[15:32:46.119]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:46.119]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:46.119]                 ...future.FUN(...future.X_jj, ...)
[15:32:46.119]             })
[15:32:46.119]         }
[15:32:46.119]     }, args = future.call.arguments)
[15:32:46.119] }
[15:32:46.119] Lazy evaluation: FALSE
[15:32:46.119] Asynchronous evaluation: FALSE
[15:32:46.119] Local evaluation: TRUE
[15:32:46.119] Environment: R_GlobalEnv
[15:32:46.119] Capture standard output: TRUE
[15:32:46.119] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:46.119] Globals: 11 objects totaling 93.06 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 848 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:46.119] Packages: 1 packages ('future.apply')
[15:32:46.119] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:46.119] Resolved: TRUE
[15:32:46.119] Value: 0 bytes of class 'NULL'
[15:32:46.119] Conditions captured: [n=1] 'simpleError'
[15:32:46.119] Early signaling: FALSE
[15:32:46.119] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:46.119] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:32:46.121] Chunk #1 of 1 ... DONE
[15:32:46.121] Launching 1 futures (chunks) ... DONE
[15:32:46.121] Resolving 1 futures (chunks) ...
[15:32:46.122] resolve() on list ...
[15:32:46.122]  recursive: 0
[15:32:46.122]  length: 1
[15:32:46.123] 
[15:32:46.123] resolved() for 'SequentialFuture' ...
[15:32:46.123] - state: 'finished'
[15:32:46.123] - run: TRUE
[15:32:46.124] - result: 'FutureResult'
[15:32:46.124] resolved() for 'SequentialFuture' ... done
[15:32:46.124] Future #1
[15:32:46.124] signalConditions() ...
[15:32:46.125]  - include = 'immediateCondition'
[15:32:46.125]  - exclude = 
[15:32:46.125]  - resignal = FALSE
[15:32:46.126]  - Number of conditions: 1
[15:32:46.126] signalConditions() ... done
[15:32:46.126] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:32:46.127] - nx: 1
[15:32:46.127] - relay: TRUE
[15:32:46.127] - stdout: TRUE
[15:32:46.127] - signal: TRUE
[15:32:46.128] - resignal: FALSE
[15:32:46.128] - force: TRUE
[15:32:46.128] - relayed: [n=1] FALSE
[15:32:46.129] - queued futures: [n=1] FALSE
[15:32:46.129]  - until=1
[15:32:46.129]  - relaying element #1
[15:32:46.129] signalConditions() ...
[15:32:46.130]  - include = 'immediateCondition'
[15:32:46.130]  - exclude = 
[15:32:46.130]  - resignal = FALSE
[15:32:46.131]  - Number of conditions: 1
[15:32:46.131] signalConditions() ... done
[15:32:46.131] signalConditions() ...
[15:32:46.132]  - include = 'immediateCondition'
[15:32:46.132]  - exclude = 
[15:32:46.132]  - resignal = FALSE
[15:32:46.132]  - Number of conditions: 1
[15:32:46.133] signalConditions() ... done
[15:32:46.133] signalConditions() ...
[15:32:46.133]  - include = 'condition'
[15:32:46.134]  - exclude = 'immediateCondition'
[15:32:46.134]  - resignal = TRUE
[15:32:46.134]  - Number of conditions: 1
[15:32:46.135]  - Condition #1: 'simpleError', 'error', 'condition'
[15:32:46.135] signalConditions() ... done
[15:32:46.135] - relayed: [n=1] FALSE
[15:32:46.136] - queued futures: [n=1] TRUE
[15:32:46.136] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:32:46.136] plan(): Setting new future strategy stack:
[15:32:46.137] List of future strategies:
[15:32:46.137] 1. sequential:
[15:32:46.137]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:46.137]    - tweaked: FALSE
[15:32:46.137]    - call: plan(sequential)
[15:32:46.138] plan(): nbrOfWorkers() = 1
*** strategy = 'sequential' ... done
*** strategy = 'multisession' ...
[15:32:46.139] plan(): Setting new future strategy stack:
[15:32:46.139] List of future strategies:
[15:32:46.139] 1. multisession:
[15:32:46.139]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:32:46.139]    - tweaked: FALSE
[15:32:46.139]    - call: plan(strategy)
[15:32:46.140] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[15:32:46.140] multisession:
[15:32:46.140] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:32:46.140] - tweaked: FALSE
[15:32:46.140] - call: plan(strategy)
[15:32:46.148] getGlobalsAndPackages() ...
[15:32:46.148] Not searching for globals
[15:32:46.149] - globals: [0] <none>
[15:32:46.149] getGlobalsAndPackages() ... DONE
[15:32:46.150] [local output] makeClusterPSOCK() ...
[15:32:46.206] [local output] Workers: [n = 2] 'localhost', 'localhost'
[15:32:46.214] [local output] Base port: 25475
[15:32:46.215] [local output] Getting setup options for 2 cluster nodes ...
[15:32:46.215] [local output]  - Node 1 of 2 ...
[15:32:46.216] [local output] localMachine=TRUE => revtunnel=FALSE

[15:32:46.218] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpiCN2Ub/worker.rank=1.parallelly.parent=83772.1473c31be7c07.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpiCN2Ub/worker.rank=1.parallelly.parent=83772.1473c31be7c07.pid\")"'
[15:32:46.656] - Possible to infer worker's PID: TRUE
[15:32:46.657] [local output] Rscript port: 25475

[15:32:46.657] [local output]  - Node 2 of 2 ...
[15:32:46.658] [local output] localMachine=TRUE => revtunnel=FALSE

[15:32:46.659] [local output] Rscript port: 25475

[15:32:46.660] [local output] Getting setup options for 2 cluster nodes ... done
[15:32:46.660] [local output]  - Parallel setup requested for some PSOCK nodes
[15:32:46.661] [local output] Setting up PSOCK nodes in parallel
[15:32:46.661] List of 36
[15:32:46.661]  $ worker          : chr "localhost"
[15:32:46.661]   ..- attr(*, "localhost")= logi TRUE
[15:32:46.661]  $ master          : chr "localhost"
[15:32:46.661]  $ port            : int 25475
[15:32:46.661]  $ connectTimeout  : num 120
[15:32:46.661]  $ timeout         : num 120
[15:32:46.661]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[15:32:46.661]  $ homogeneous     : logi TRUE
[15:32:46.661]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=future_vapply.R:83772:CRANWIN3:C"| __truncated__
[15:32:46.661]  $ rscript_envs    : NULL
[15:32:46.661]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:32:46.661]  $ rscript_startup : NULL
[15:32:46.661]  $ rscript_sh      : chr "cmd"
[15:32:46.661]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:32:46.661]  $ methods         : logi TRUE
[15:32:46.661]  $ socketOptions   : chr "no-delay"
[15:32:46.661]  $ useXDR          : logi FALSE
[15:32:46.661]  $ outfile         : chr "/dev/null"
[15:32:46.661]  $ renice          : int NA
[15:32:46.661]  $ rshcmd          : NULL
[15:32:46.661]  $ user            : chr(0) 
[15:32:46.661]  $ revtunnel       : logi FALSE
[15:32:46.661]  $ rshlogfile      : NULL
[15:32:46.661]  $ rshopts         : chr(0) 
[15:32:46.661]  $ rank            : int 1
[15:32:46.661]  $ manual          : logi FALSE
[15:32:46.661]  $ dryrun          : logi FALSE
[15:32:46.661]  $ quiet           : logi FALSE
[15:32:46.661]  $ setup_strategy  : chr "parallel"
[15:32:46.661]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:32:46.661]  $ pidfile         : chr "D:/temp/RtmpiCN2Ub/worker.rank=1.parallelly.parent=83772.1473c31be7c07.pid"
[15:32:46.661]  $ rshcmd_label    : NULL
[15:32:46.661]  $ rsh_call        : NULL
[15:32:46.661]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:32:46.661]  $ localMachine    : logi TRUE
[15:32:46.661]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[15:32:46.661]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[15:32:46.661]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[15:32:46.661]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[15:32:46.661]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[15:32:46.661]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[15:32:46.661]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[15:32:46.661]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[15:32:46.661]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[15:32:46.661]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[15:32:46.661]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[15:32:46.661]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[15:32:46.661]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[15:32:46.661]  $ arguments       :List of 28
[15:32:46.661]   ..$ worker          : chr "localhost"
[15:32:46.661]   ..$ master          : NULL
[15:32:46.661]   ..$ port            : int 25475
[15:32:46.661]   ..$ connectTimeout  : num 120
[15:32:46.661]   ..$ timeout         : num 120
[15:32:46.661]   ..$ rscript         : NULL
[15:32:46.661]   ..$ homogeneous     : NULL
[15:32:46.661]   ..$ rscript_args    : NULL
[15:32:46.661]   ..$ rscript_envs    : NULL
[15:32:46.661]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:32:46.661]   ..$ rscript_startup : NULL
[15:32:46.661]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[15:32:46.661]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:32:46.661]   ..$ methods         : logi TRUE
[15:32:46.661]   ..$ socketOptions   : chr "no-delay"
[15:32:46.661]   ..$ useXDR          : logi FALSE
[15:32:46.661]   ..$ outfile         : chr "/dev/null"
[15:32:46.661]   ..$ renice          : int NA
[15:32:46.661]   ..$ rshcmd          : NULL
[15:32:46.661]   ..$ user            : NULL
[15:32:46.661]   ..$ revtunnel       : logi NA
[15:32:46.661]   ..$ rshlogfile      : NULL
[15:32:46.661]   ..$ rshopts         : NULL
[15:32:46.661]   ..$ rank            : int 1
[15:32:46.661]   ..$ manual          : logi FALSE
[15:32:46.661]   ..$ dryrun          : logi FALSE
[15:32:46.661]   ..$ quiet           : logi FALSE
[15:32:46.661]   ..$ setup_strategy  : chr "parallel"
[15:32:46.661]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[15:32:46.684] [local output] System call to launch all workers:
[15:32:46.684] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=future_vapply.R:83772:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpiCN2Ub/worker.rank=1.parallelly.parent=83772.1473c31be7c07.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=25475 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[15:32:46.684] [local output] Starting PSOCK main server
[15:32:46.693] [local output] Workers launched
[15:32:46.694] [local output] Waiting for workers to connect back
[15:32:46.694]  - [local output] 0 workers out of 2 ready
[15:32:46.931]  - [local output] 0 workers out of 2 ready
[15:32:46.933]  - [local output] 1 workers out of 2 ready
[15:32:46.933]  - [local output] 2 workers out of 2 ready
[15:32:46.934] [local output] Launching of workers completed
[15:32:46.934] [local output] Collecting session information from workers
[15:32:46.935] [local output]  - Worker #1 of 2
[15:32:46.936] [local output]  - Worker #2 of 2
[15:32:46.937] [local output] makeClusterPSOCK() ... done
[15:32:46.953] Packages needed by the future expression (n = 0): <none>
[15:32:46.954] Packages needed by future strategies (n = 0): <none>
[15:32:46.955] {
[15:32:46.955]     {
[15:32:46.955]         {
[15:32:46.955]             ...future.startTime <- base::Sys.time()
[15:32:46.955]             {
[15:32:46.955]                 {
[15:32:46.955]                   {
[15:32:46.955]                     {
[15:32:46.955]                       base::local({
[15:32:46.955]                         has_future <- base::requireNamespace("future", 
[15:32:46.955]                           quietly = TRUE)
[15:32:46.955]                         if (has_future) {
[15:32:46.955]                           ns <- base::getNamespace("future")
[15:32:46.955]                           version <- ns[[".package"]][["version"]]
[15:32:46.955]                           if (is.null(version)) 
[15:32:46.955]                             version <- utils::packageVersion("future")
[15:32:46.955]                         }
[15:32:46.955]                         else {
[15:32:46.955]                           version <- NULL
[15:32:46.955]                         }
[15:32:46.955]                         if (!has_future || version < "1.8.0") {
[15:32:46.955]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:46.955]                             "", base::R.version$version.string), 
[15:32:46.955]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:46.955]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:46.955]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:46.955]                               "release", "version")], collapse = " "), 
[15:32:46.955]                             hostname = base::Sys.info()[["nodename"]])
[15:32:46.955]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:46.955]                             info)
[15:32:46.955]                           info <- base::paste(info, collapse = "; ")
[15:32:46.955]                           if (!has_future) {
[15:32:46.955]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:46.955]                               info)
[15:32:46.955]                           }
[15:32:46.955]                           else {
[15:32:46.955]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:46.955]                               info, version)
[15:32:46.955]                           }
[15:32:46.955]                           base::stop(msg)
[15:32:46.955]                         }
[15:32:46.955]                       })
[15:32:46.955]                     }
[15:32:46.955]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:46.955]                     base::options(mc.cores = 1L)
[15:32:46.955]                   }
[15:32:46.955]                   ...future.strategy.old <- future::plan("list")
[15:32:46.955]                   options(future.plan = NULL)
[15:32:46.955]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:46.955]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:46.955]                 }
[15:32:46.955]                 ...future.workdir <- getwd()
[15:32:46.955]             }
[15:32:46.955]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:46.955]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:46.955]         }
[15:32:46.955]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:46.955]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:32:46.955]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:46.955]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:46.955]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:46.955]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:46.955]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:46.955]             base::names(...future.oldOptions))
[15:32:46.955]     }
[15:32:46.955]     if (FALSE) {
[15:32:46.955]     }
[15:32:46.955]     else {
[15:32:46.955]         if (TRUE) {
[15:32:46.955]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:46.955]                 open = "w")
[15:32:46.955]         }
[15:32:46.955]         else {
[15:32:46.955]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:46.955]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:46.955]         }
[15:32:46.955]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:46.955]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:46.955]             base::sink(type = "output", split = FALSE)
[15:32:46.955]             base::close(...future.stdout)
[15:32:46.955]         }, add = TRUE)
[15:32:46.955]     }
[15:32:46.955]     ...future.frame <- base::sys.nframe()
[15:32:46.955]     ...future.conditions <- base::list()
[15:32:46.955]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:46.955]     if (FALSE) {
[15:32:46.955]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:46.955]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:46.955]     }
[15:32:46.955]     ...future.result <- base::tryCatch({
[15:32:46.955]         base::withCallingHandlers({
[15:32:46.955]             ...future.value <- base::withVisible(base::local({
[15:32:46.955]                 ...future.makeSendCondition <- base::local({
[15:32:46.955]                   sendCondition <- NULL
[15:32:46.955]                   function(frame = 1L) {
[15:32:46.955]                     if (is.function(sendCondition)) 
[15:32:46.955]                       return(sendCondition)
[15:32:46.955]                     ns <- getNamespace("parallel")
[15:32:46.955]                     if (exists("sendData", mode = "function", 
[15:32:46.955]                       envir = ns)) {
[15:32:46.955]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:46.955]                         envir = ns)
[15:32:46.955]                       envir <- sys.frame(frame)
[15:32:46.955]                       master <- NULL
[15:32:46.955]                       while (!identical(envir, .GlobalEnv) && 
[15:32:46.955]                         !identical(envir, emptyenv())) {
[15:32:46.955]                         if (exists("master", mode = "list", envir = envir, 
[15:32:46.955]                           inherits = FALSE)) {
[15:32:46.955]                           master <- get("master", mode = "list", 
[15:32:46.955]                             envir = envir, inherits = FALSE)
[15:32:46.955]                           if (inherits(master, c("SOCKnode", 
[15:32:46.955]                             "SOCK0node"))) {
[15:32:46.955]                             sendCondition <<- function(cond) {
[15:32:46.955]                               data <- list(type = "VALUE", value = cond, 
[15:32:46.955]                                 success = TRUE)
[15:32:46.955]                               parallel_sendData(master, data)
[15:32:46.955]                             }
[15:32:46.955]                             return(sendCondition)
[15:32:46.955]                           }
[15:32:46.955]                         }
[15:32:46.955]                         frame <- frame + 1L
[15:32:46.955]                         envir <- sys.frame(frame)
[15:32:46.955]                       }
[15:32:46.955]                     }
[15:32:46.955]                     sendCondition <<- function(cond) NULL
[15:32:46.955]                   }
[15:32:46.955]                 })
[15:32:46.955]                 withCallingHandlers({
[15:32:46.955]                   NA
[15:32:46.955]                 }, immediateCondition = function(cond) {
[15:32:46.955]                   sendCondition <- ...future.makeSendCondition()
[15:32:46.955]                   sendCondition(cond)
[15:32:46.955]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:46.955]                   {
[15:32:46.955]                     inherits <- base::inherits
[15:32:46.955]                     invokeRestart <- base::invokeRestart
[15:32:46.955]                     is.null <- base::is.null
[15:32:46.955]                     muffled <- FALSE
[15:32:46.955]                     if (inherits(cond, "message")) {
[15:32:46.955]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:46.955]                       if (muffled) 
[15:32:46.955]                         invokeRestart("muffleMessage")
[15:32:46.955]                     }
[15:32:46.955]                     else if (inherits(cond, "warning")) {
[15:32:46.955]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:46.955]                       if (muffled) 
[15:32:46.955]                         invokeRestart("muffleWarning")
[15:32:46.955]                     }
[15:32:46.955]                     else if (inherits(cond, "condition")) {
[15:32:46.955]                       if (!is.null(pattern)) {
[15:32:46.955]                         computeRestarts <- base::computeRestarts
[15:32:46.955]                         grepl <- base::grepl
[15:32:46.955]                         restarts <- computeRestarts(cond)
[15:32:46.955]                         for (restart in restarts) {
[15:32:46.955]                           name <- restart$name
[15:32:46.955]                           if (is.null(name)) 
[15:32:46.955]                             next
[15:32:46.955]                           if (!grepl(pattern, name)) 
[15:32:46.955]                             next
[15:32:46.955]                           invokeRestart(restart)
[15:32:46.955]                           muffled <- TRUE
[15:32:46.955]                           break
[15:32:46.955]                         }
[15:32:46.955]                       }
[15:32:46.955]                     }
[15:32:46.955]                     invisible(muffled)
[15:32:46.955]                   }
[15:32:46.955]                   muffleCondition(cond)
[15:32:46.955]                 })
[15:32:46.955]             }))
[15:32:46.955]             future::FutureResult(value = ...future.value$value, 
[15:32:46.955]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:46.955]                   ...future.rng), globalenv = if (FALSE) 
[15:32:46.955]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:46.955]                     ...future.globalenv.names))
[15:32:46.955]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:46.955]         }, condition = base::local({
[15:32:46.955]             c <- base::c
[15:32:46.955]             inherits <- base::inherits
[15:32:46.955]             invokeRestart <- base::invokeRestart
[15:32:46.955]             length <- base::length
[15:32:46.955]             list <- base::list
[15:32:46.955]             seq.int <- base::seq.int
[15:32:46.955]             signalCondition <- base::signalCondition
[15:32:46.955]             sys.calls <- base::sys.calls
[15:32:46.955]             `[[` <- base::`[[`
[15:32:46.955]             `+` <- base::`+`
[15:32:46.955]             `<<-` <- base::`<<-`
[15:32:46.955]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:46.955]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:46.955]                   3L)]
[15:32:46.955]             }
[15:32:46.955]             function(cond) {
[15:32:46.955]                 is_error <- inherits(cond, "error")
[15:32:46.955]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:46.955]                   NULL)
[15:32:46.955]                 if (is_error) {
[15:32:46.955]                   sessionInformation <- function() {
[15:32:46.955]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:46.955]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:46.955]                       search = base::search(), system = base::Sys.info())
[15:32:46.955]                   }
[15:32:46.955]                   ...future.conditions[[length(...future.conditions) + 
[15:32:46.955]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:46.955]                     cond$call), session = sessionInformation(), 
[15:32:46.955]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:46.955]                   signalCondition(cond)
[15:32:46.955]                 }
[15:32:46.955]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:46.955]                 "immediateCondition"))) {
[15:32:46.955]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:46.955]                   ...future.conditions[[length(...future.conditions) + 
[15:32:46.955]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:46.955]                   if (TRUE && !signal) {
[15:32:46.955]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:46.955]                     {
[15:32:46.955]                       inherits <- base::inherits
[15:32:46.955]                       invokeRestart <- base::invokeRestart
[15:32:46.955]                       is.null <- base::is.null
[15:32:46.955]                       muffled <- FALSE
[15:32:46.955]                       if (inherits(cond, "message")) {
[15:32:46.955]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:46.955]                         if (muffled) 
[15:32:46.955]                           invokeRestart("muffleMessage")
[15:32:46.955]                       }
[15:32:46.955]                       else if (inherits(cond, "warning")) {
[15:32:46.955]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:46.955]                         if (muffled) 
[15:32:46.955]                           invokeRestart("muffleWarning")
[15:32:46.955]                       }
[15:32:46.955]                       else if (inherits(cond, "condition")) {
[15:32:46.955]                         if (!is.null(pattern)) {
[15:32:46.955]                           computeRestarts <- base::computeRestarts
[15:32:46.955]                           grepl <- base::grepl
[15:32:46.955]                           restarts <- computeRestarts(cond)
[15:32:46.955]                           for (restart in restarts) {
[15:32:46.955]                             name <- restart$name
[15:32:46.955]                             if (is.null(name)) 
[15:32:46.955]                               next
[15:32:46.955]                             if (!grepl(pattern, name)) 
[15:32:46.955]                               next
[15:32:46.955]                             invokeRestart(restart)
[15:32:46.955]                             muffled <- TRUE
[15:32:46.955]                             break
[15:32:46.955]                           }
[15:32:46.955]                         }
[15:32:46.955]                       }
[15:32:46.955]                       invisible(muffled)
[15:32:46.955]                     }
[15:32:46.955]                     muffleCondition(cond, pattern = "^muffle")
[15:32:46.955]                   }
[15:32:46.955]                 }
[15:32:46.955]                 else {
[15:32:46.955]                   if (TRUE) {
[15:32:46.955]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:46.955]                     {
[15:32:46.955]                       inherits <- base::inherits
[15:32:46.955]                       invokeRestart <- base::invokeRestart
[15:32:46.955]                       is.null <- base::is.null
[15:32:46.955]                       muffled <- FALSE
[15:32:46.955]                       if (inherits(cond, "message")) {
[15:32:46.955]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:46.955]                         if (muffled) 
[15:32:46.955]                           invokeRestart("muffleMessage")
[15:32:46.955]                       }
[15:32:46.955]                       else if (inherits(cond, "warning")) {
[15:32:46.955]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:46.955]                         if (muffled) 
[15:32:46.955]                           invokeRestart("muffleWarning")
[15:32:46.955]                       }
[15:32:46.955]                       else if (inherits(cond, "condition")) {
[15:32:46.955]                         if (!is.null(pattern)) {
[15:32:46.955]                           computeRestarts <- base::computeRestarts
[15:32:46.955]                           grepl <- base::grepl
[15:32:46.955]                           restarts <- computeRestarts(cond)
[15:32:46.955]                           for (restart in restarts) {
[15:32:46.955]                             name <- restart$name
[15:32:46.955]                             if (is.null(name)) 
[15:32:46.955]                               next
[15:32:46.955]                             if (!grepl(pattern, name)) 
[15:32:46.955]                               next
[15:32:46.955]                             invokeRestart(restart)
[15:32:46.955]                             muffled <- TRUE
[15:32:46.955]                             break
[15:32:46.955]                           }
[15:32:46.955]                         }
[15:32:46.955]                       }
[15:32:46.955]                       invisible(muffled)
[15:32:46.955]                     }
[15:32:46.955]                     muffleCondition(cond, pattern = "^muffle")
[15:32:46.955]                   }
[15:32:46.955]                 }
[15:32:46.955]             }
[15:32:46.955]         }))
[15:32:46.955]     }, error = function(ex) {
[15:32:46.955]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:46.955]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:46.955]                 ...future.rng), started = ...future.startTime, 
[15:32:46.955]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:46.955]             version = "1.8"), class = "FutureResult")
[15:32:46.955]     }, finally = {
[15:32:46.955]         if (!identical(...future.workdir, getwd())) 
[15:32:46.955]             setwd(...future.workdir)
[15:32:46.955]         {
[15:32:46.955]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:46.955]                 ...future.oldOptions$nwarnings <- NULL
[15:32:46.955]             }
[15:32:46.955]             base::options(...future.oldOptions)
[15:32:46.955]             if (.Platform$OS.type == "windows") {
[15:32:46.955]                 old_names <- names(...future.oldEnvVars)
[15:32:46.955]                 envs <- base::Sys.getenv()
[15:32:46.955]                 names <- names(envs)
[15:32:46.955]                 common <- intersect(names, old_names)
[15:32:46.955]                 added <- setdiff(names, old_names)
[15:32:46.955]                 removed <- setdiff(old_names, names)
[15:32:46.955]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:46.955]                   envs[common]]
[15:32:46.955]                 NAMES <- toupper(changed)
[15:32:46.955]                 args <- list()
[15:32:46.955]                 for (kk in seq_along(NAMES)) {
[15:32:46.955]                   name <- changed[[kk]]
[15:32:46.955]                   NAME <- NAMES[[kk]]
[15:32:46.955]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:46.955]                     next
[15:32:46.955]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:46.955]                 }
[15:32:46.955]                 NAMES <- toupper(added)
[15:32:46.955]                 for (kk in seq_along(NAMES)) {
[15:32:46.955]                   name <- added[[kk]]
[15:32:46.955]                   NAME <- NAMES[[kk]]
[15:32:46.955]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:46.955]                     next
[15:32:46.955]                   args[[name]] <- ""
[15:32:46.955]                 }
[15:32:46.955]                 NAMES <- toupper(removed)
[15:32:46.955]                 for (kk in seq_along(NAMES)) {
[15:32:46.955]                   name <- removed[[kk]]
[15:32:46.955]                   NAME <- NAMES[[kk]]
[15:32:46.955]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:46.955]                     next
[15:32:46.955]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:46.955]                 }
[15:32:46.955]                 if (length(args) > 0) 
[15:32:46.955]                   base::do.call(base::Sys.setenv, args = args)
[15:32:46.955]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:46.955]             }
[15:32:46.955]             else {
[15:32:46.955]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:46.955]             }
[15:32:46.955]             {
[15:32:46.955]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:46.955]                   0L) {
[15:32:46.955]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:46.955]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:46.955]                   base::options(opts)
[15:32:46.955]                 }
[15:32:46.955]                 {
[15:32:46.955]                   {
[15:32:46.955]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:46.955]                     NULL
[15:32:46.955]                   }
[15:32:46.955]                   options(future.plan = NULL)
[15:32:46.955]                   if (is.na(NA_character_)) 
[15:32:46.955]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:46.955]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:46.955]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:46.955]                     .init = FALSE)
[15:32:46.955]                 }
[15:32:46.955]             }
[15:32:46.955]         }
[15:32:46.955]     })
[15:32:46.955]     if (TRUE) {
[15:32:46.955]         base::sink(type = "output", split = FALSE)
[15:32:46.955]         if (TRUE) {
[15:32:46.955]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:46.955]         }
[15:32:46.955]         else {
[15:32:46.955]             ...future.result["stdout"] <- base::list(NULL)
[15:32:46.955]         }
[15:32:46.955]         base::close(...future.stdout)
[15:32:46.955]         ...future.stdout <- NULL
[15:32:46.955]     }
[15:32:46.955]     ...future.result$conditions <- ...future.conditions
[15:32:46.955]     ...future.result$finished <- base::Sys.time()
[15:32:46.955]     ...future.result
[15:32:46.955] }
[15:32:47.099] MultisessionFuture started
[15:32:47.100] result() for ClusterFuture ...
[15:32:47.101] receiveMessageFromWorker() for ClusterFuture ...
[15:32:47.101] - Validating connection of MultisessionFuture
[15:32:47.185] - received message: FutureResult
[15:32:47.186] - Received FutureResult
[15:32:47.192] - Erased future from FutureRegistry
[15:32:47.192] result() for ClusterFuture ...
[15:32:47.192] - result already collected: FutureResult
[15:32:47.192] result() for ClusterFuture ... done
[15:32:47.193] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:47.193] result() for ClusterFuture ... done
[15:32:47.193] result() for ClusterFuture ...
[15:32:47.194] - result already collected: FutureResult
[15:32:47.194] result() for ClusterFuture ... done
[15:32:47.195] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[15:32:47.199] plan(): nbrOfWorkers() = 2
 logi(0) 
 logi(0) 
 logi(0) 
 logi(0) 
 logi(0) 
 int(0) 
 int(0) 
 Named chr [1:2] "integer" "character"
 - attr(*, "names")= chr [1:2] "x" "y"
[15:32:47.204] future_lapply() ...
[15:32:47.213] Number of chunks: 2
[15:32:47.213] getGlobalsAndPackagesXApply() ...
[15:32:47.214]  - future.globals: TRUE
[15:32:47.214] getGlobalsAndPackages() ...
[15:32:47.214] Searching for globals...
[15:32:47.221] - globals found: [16] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types'
[15:32:47.222] Searching for globals ... DONE
[15:32:47.222] Resolving globals: FALSE
[15:32:47.224] The total size of the 7 globals is 92.00 KiB (94208 bytes)
[15:32:47.225] The total size of the 7 globals exported for future expression ('FUN()') is 92.00 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:47.225] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:47.226] - packages: [1] 'future.apply'
[15:32:47.226] getGlobalsAndPackages() ... DONE
[15:32:47.226]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:47.227]  - needed namespaces: [n=1] 'future.apply'
[15:32:47.227] Finding globals ... DONE
[15:32:47.227]  - use_args: TRUE
[15:32:47.228]  - Getting '...' globals ...
[15:32:47.229] resolve() on list ...
[15:32:47.229]  recursive: 0
[15:32:47.229]  length: 1
[15:32:47.230]  elements: '...'
[15:32:47.230]  length: 0 (resolved future 1)
[15:32:47.231] resolve() on list ... DONE
[15:32:47.231]    - '...' content: [n=0] 
[15:32:47.231] List of 1
[15:32:47.231]  $ ...: list()
[15:32:47.231]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:47.231]  - attr(*, "where")=List of 1
[15:32:47.231]   ..$ ...:<environment: 0x0000022d40e57b58> 
[15:32:47.231]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:47.231]  - attr(*, "resolved")= logi TRUE
[15:32:47.231]  - attr(*, "total_size")= num NA
[15:32:47.238]  - Getting '...' globals ... DONE
[15:32:47.239] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:47.239] List of 8
[15:32:47.239]  $ ...future.FUN:function (x, ...)  
[15:32:47.239]  $ x_FUN        :function (x)  
[15:32:47.239]  $ times        : int 1
[15:32:47.239]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:47.239]  $ stop_if_not  :function (...)  
[15:32:47.239]  $ dim          : NULL
[15:32:47.239]  $ valid_types  : chr "character"
[15:32:47.239]  $ ...          : list()
[15:32:47.239]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:47.239]  - attr(*, "where")=List of 8
[15:32:47.239]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:47.239]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:47.239]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:47.239]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:47.239]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:47.239]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:47.239]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:47.239]   ..$ ...          :<environment: 0x0000022d40e57b58> 
[15:32:47.239]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:47.239]  - attr(*, "resolved")= logi FALSE
[15:32:47.239]  - attr(*, "total_size")= num 94208
[15:32:47.253] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:47.254] getGlobalsAndPackagesXApply() ... DONE
[15:32:47.254] Number of futures (= number of chunks): 2
[15:32:47.255] Launching 2 futures (chunks) ...
[15:32:47.255] Chunk #1 of 2 ...
[15:32:47.255]  - Finding globals in 'X' for chunk #1 ...
[15:32:47.256] getGlobalsAndPackages() ...
[15:32:47.256] Searching for globals...
[15:32:47.257] 
[15:32:47.257] Searching for globals ... DONE
[15:32:47.257] - globals: [0] <none>
[15:32:47.258] getGlobalsAndPackages() ... DONE
[15:32:47.258]    + additional globals found: [n=0] 
[15:32:47.258]    + additional namespaces needed: [n=0] 
[15:32:47.259]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:47.259]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:47.259]  - seeds: <none>
[15:32:47.259]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.260] getGlobalsAndPackages() ...
[15:32:47.260] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.260] Resolving globals: FALSE
[15:32:47.261] Tweak future expression to call with '...' arguments ...
[15:32:47.261] {
[15:32:47.261]     do.call(function(...) {
[15:32:47.261]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.261]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.261]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.261]             on.exit(options(oopts), add = TRUE)
[15:32:47.261]         }
[15:32:47.261]         {
[15:32:47.261]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.261]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.261]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.261]             })
[15:32:47.261]         }
[15:32:47.261]     }, args = future.call.arguments)
[15:32:47.261] }
[15:32:47.262] Tweak future expression to call with '...' arguments ... DONE
[15:32:47.263] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.264] - packages: [1] 'future.apply'
[15:32:47.264] getGlobalsAndPackages() ... DONE
[15:32:47.265] run() for 'Future' ...
[15:32:47.265] - state: 'created'
[15:32:47.266] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:47.288] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:47.289] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:47.289]   - Field: 'node'
[15:32:47.290]   - Field: 'label'
[15:32:47.290]   - Field: 'local'
[15:32:47.291]   - Field: 'owner'
[15:32:47.291]   - Field: 'envir'
[15:32:47.291]   - Field: 'workers'
[15:32:47.292]   - Field: 'packages'
[15:32:47.292]   - Field: 'gc'
[15:32:47.292]   - Field: 'conditions'
[15:32:47.293]   - Field: 'persistent'
[15:32:47.293]   - Field: 'expr'
[15:32:47.293]   - Field: 'uuid'
[15:32:47.294]   - Field: 'seed'
[15:32:47.294]   - Field: 'version'
[15:32:47.294]   - Field: 'result'
[15:32:47.295]   - Field: 'asynchronous'
[15:32:47.295]   - Field: 'calls'
[15:32:47.295]   - Field: 'globals'
[15:32:47.296]   - Field: 'stdout'
[15:32:47.296]   - Field: 'earlySignal'
[15:32:47.297]   - Field: 'lazy'
[15:32:47.297]   - Field: 'state'
[15:32:47.297] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:47.298] - Launch lazy future ...
[15:32:47.298] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:47.299] Packages needed by future strategies (n = 0): <none>
[15:32:47.300] {
[15:32:47.300]     {
[15:32:47.300]         {
[15:32:47.300]             ...future.startTime <- base::Sys.time()
[15:32:47.300]             {
[15:32:47.300]                 {
[15:32:47.300]                   {
[15:32:47.300]                     {
[15:32:47.300]                       {
[15:32:47.300]                         base::local({
[15:32:47.300]                           has_future <- base::requireNamespace("future", 
[15:32:47.300]                             quietly = TRUE)
[15:32:47.300]                           if (has_future) {
[15:32:47.300]                             ns <- base::getNamespace("future")
[15:32:47.300]                             version <- ns[[".package"]][["version"]]
[15:32:47.300]                             if (is.null(version)) 
[15:32:47.300]                               version <- utils::packageVersion("future")
[15:32:47.300]                           }
[15:32:47.300]                           else {
[15:32:47.300]                             version <- NULL
[15:32:47.300]                           }
[15:32:47.300]                           if (!has_future || version < "1.8.0") {
[15:32:47.300]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:47.300]                               "", base::R.version$version.string), 
[15:32:47.300]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:47.300]                                 base::R.version$platform, 8 * 
[15:32:47.300]                                   base::.Machine$sizeof.pointer), 
[15:32:47.300]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:47.300]                                 "release", "version")], collapse = " "), 
[15:32:47.300]                               hostname = base::Sys.info()[["nodename"]])
[15:32:47.300]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:47.300]                               info)
[15:32:47.300]                             info <- base::paste(info, collapse = "; ")
[15:32:47.300]                             if (!has_future) {
[15:32:47.300]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:47.300]                                 info)
[15:32:47.300]                             }
[15:32:47.300]                             else {
[15:32:47.300]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:47.300]                                 info, version)
[15:32:47.300]                             }
[15:32:47.300]                             base::stop(msg)
[15:32:47.300]                           }
[15:32:47.300]                         })
[15:32:47.300]                       }
[15:32:47.300]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:47.300]                       base::options(mc.cores = 1L)
[15:32:47.300]                     }
[15:32:47.300]                     base::local({
[15:32:47.300]                       for (pkg in "future.apply") {
[15:32:47.300]                         base::loadNamespace(pkg)
[15:32:47.300]                         base::library(pkg, character.only = TRUE)
[15:32:47.300]                       }
[15:32:47.300]                     })
[15:32:47.300]                   }
[15:32:47.300]                   ...future.strategy.old <- future::plan("list")
[15:32:47.300]                   options(future.plan = NULL)
[15:32:47.300]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:47.300]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:47.300]                 }
[15:32:47.300]                 ...future.workdir <- getwd()
[15:32:47.300]             }
[15:32:47.300]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:47.300]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:47.300]         }
[15:32:47.300]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:47.300]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:47.300]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:47.300]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:47.300]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:47.300]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:47.300]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:47.300]             base::names(...future.oldOptions))
[15:32:47.300]     }
[15:32:47.300]     if (FALSE) {
[15:32:47.300]     }
[15:32:47.300]     else {
[15:32:47.300]         if (TRUE) {
[15:32:47.300]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:47.300]                 open = "w")
[15:32:47.300]         }
[15:32:47.300]         else {
[15:32:47.300]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:47.300]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:47.300]         }
[15:32:47.300]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:47.300]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:47.300]             base::sink(type = "output", split = FALSE)
[15:32:47.300]             base::close(...future.stdout)
[15:32:47.300]         }, add = TRUE)
[15:32:47.300]     }
[15:32:47.300]     ...future.frame <- base::sys.nframe()
[15:32:47.300]     ...future.conditions <- base::list()
[15:32:47.300]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:47.300]     if (FALSE) {
[15:32:47.300]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:47.300]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:47.300]     }
[15:32:47.300]     ...future.result <- base::tryCatch({
[15:32:47.300]         base::withCallingHandlers({
[15:32:47.300]             ...future.value <- base::withVisible(base::local({
[15:32:47.300]                 ...future.makeSendCondition <- base::local({
[15:32:47.300]                   sendCondition <- NULL
[15:32:47.300]                   function(frame = 1L) {
[15:32:47.300]                     if (is.function(sendCondition)) 
[15:32:47.300]                       return(sendCondition)
[15:32:47.300]                     ns <- getNamespace("parallel")
[15:32:47.300]                     if (exists("sendData", mode = "function", 
[15:32:47.300]                       envir = ns)) {
[15:32:47.300]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:47.300]                         envir = ns)
[15:32:47.300]                       envir <- sys.frame(frame)
[15:32:47.300]                       master <- NULL
[15:32:47.300]                       while (!identical(envir, .GlobalEnv) && 
[15:32:47.300]                         !identical(envir, emptyenv())) {
[15:32:47.300]                         if (exists("master", mode = "list", envir = envir, 
[15:32:47.300]                           inherits = FALSE)) {
[15:32:47.300]                           master <- get("master", mode = "list", 
[15:32:47.300]                             envir = envir, inherits = FALSE)
[15:32:47.300]                           if (inherits(master, c("SOCKnode", 
[15:32:47.300]                             "SOCK0node"))) {
[15:32:47.300]                             sendCondition <<- function(cond) {
[15:32:47.300]                               data <- list(type = "VALUE", value = cond, 
[15:32:47.300]                                 success = TRUE)
[15:32:47.300]                               parallel_sendData(master, data)
[15:32:47.300]                             }
[15:32:47.300]                             return(sendCondition)
[15:32:47.300]                           }
[15:32:47.300]                         }
[15:32:47.300]                         frame <- frame + 1L
[15:32:47.300]                         envir <- sys.frame(frame)
[15:32:47.300]                       }
[15:32:47.300]                     }
[15:32:47.300]                     sendCondition <<- function(cond) NULL
[15:32:47.300]                   }
[15:32:47.300]                 })
[15:32:47.300]                 withCallingHandlers({
[15:32:47.300]                   {
[15:32:47.300]                     do.call(function(...) {
[15:32:47.300]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.300]                       if (!identical(...future.globals.maxSize.org, 
[15:32:47.300]                         ...future.globals.maxSize)) {
[15:32:47.300]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.300]                         on.exit(options(oopts), add = TRUE)
[15:32:47.300]                       }
[15:32:47.300]                       {
[15:32:47.300]                         lapply(seq_along(...future.elements_ii), 
[15:32:47.300]                           FUN = function(jj) {
[15:32:47.300]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.300]                             ...future.FUN(...future.X_jj, ...)
[15:32:47.300]                           })
[15:32:47.300]                       }
[15:32:47.300]                     }, args = future.call.arguments)
[15:32:47.300]                   }
[15:32:47.300]                 }, immediateCondition = function(cond) {
[15:32:47.300]                   sendCondition <- ...future.makeSendCondition()
[15:32:47.300]                   sendCondition(cond)
[15:32:47.300]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.300]                   {
[15:32:47.300]                     inherits <- base::inherits
[15:32:47.300]                     invokeRestart <- base::invokeRestart
[15:32:47.300]                     is.null <- base::is.null
[15:32:47.300]                     muffled <- FALSE
[15:32:47.300]                     if (inherits(cond, "message")) {
[15:32:47.300]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:47.300]                       if (muffled) 
[15:32:47.300]                         invokeRestart("muffleMessage")
[15:32:47.300]                     }
[15:32:47.300]                     else if (inherits(cond, "warning")) {
[15:32:47.300]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:47.300]                       if (muffled) 
[15:32:47.300]                         invokeRestart("muffleWarning")
[15:32:47.300]                     }
[15:32:47.300]                     else if (inherits(cond, "condition")) {
[15:32:47.300]                       if (!is.null(pattern)) {
[15:32:47.300]                         computeRestarts <- base::computeRestarts
[15:32:47.300]                         grepl <- base::grepl
[15:32:47.300]                         restarts <- computeRestarts(cond)
[15:32:47.300]                         for (restart in restarts) {
[15:32:47.300]                           name <- restart$name
[15:32:47.300]                           if (is.null(name)) 
[15:32:47.300]                             next
[15:32:47.300]                           if (!grepl(pattern, name)) 
[15:32:47.300]                             next
[15:32:47.300]                           invokeRestart(restart)
[15:32:47.300]                           muffled <- TRUE
[15:32:47.300]                           break
[15:32:47.300]                         }
[15:32:47.300]                       }
[15:32:47.300]                     }
[15:32:47.300]                     invisible(muffled)
[15:32:47.300]                   }
[15:32:47.300]                   muffleCondition(cond)
[15:32:47.300]                 })
[15:32:47.300]             }))
[15:32:47.300]             future::FutureResult(value = ...future.value$value, 
[15:32:47.300]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:47.300]                   ...future.rng), globalenv = if (FALSE) 
[15:32:47.300]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:47.300]                     ...future.globalenv.names))
[15:32:47.300]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:47.300]         }, condition = base::local({
[15:32:47.300]             c <- base::c
[15:32:47.300]             inherits <- base::inherits
[15:32:47.300]             invokeRestart <- base::invokeRestart
[15:32:47.300]             length <- base::length
[15:32:47.300]             list <- base::list
[15:32:47.300]             seq.int <- base::seq.int
[15:32:47.300]             signalCondition <- base::signalCondition
[15:32:47.300]             sys.calls <- base::sys.calls
[15:32:47.300]             `[[` <- base::`[[`
[15:32:47.300]             `+` <- base::`+`
[15:32:47.300]             `<<-` <- base::`<<-`
[15:32:47.300]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:47.300]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:47.300]                   3L)]
[15:32:47.300]             }
[15:32:47.300]             function(cond) {
[15:32:47.300]                 is_error <- inherits(cond, "error")
[15:32:47.300]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:47.300]                   NULL)
[15:32:47.300]                 if (is_error) {
[15:32:47.300]                   sessionInformation <- function() {
[15:32:47.300]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:47.300]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:47.300]                       search = base::search(), system = base::Sys.info())
[15:32:47.300]                   }
[15:32:47.300]                   ...future.conditions[[length(...future.conditions) + 
[15:32:47.300]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:47.300]                     cond$call), session = sessionInformation(), 
[15:32:47.300]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:47.300]                   signalCondition(cond)
[15:32:47.300]                 }
[15:32:47.300]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:47.300]                 "immediateCondition"))) {
[15:32:47.300]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:47.300]                   ...future.conditions[[length(...future.conditions) + 
[15:32:47.300]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:47.300]                   if (TRUE && !signal) {
[15:32:47.300]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.300]                     {
[15:32:47.300]                       inherits <- base::inherits
[15:32:47.300]                       invokeRestart <- base::invokeRestart
[15:32:47.300]                       is.null <- base::is.null
[15:32:47.300]                       muffled <- FALSE
[15:32:47.300]                       if (inherits(cond, "message")) {
[15:32:47.300]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:47.300]                         if (muffled) 
[15:32:47.300]                           invokeRestart("muffleMessage")
[15:32:47.300]                       }
[15:32:47.300]                       else if (inherits(cond, "warning")) {
[15:32:47.300]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:47.300]                         if (muffled) 
[15:32:47.300]                           invokeRestart("muffleWarning")
[15:32:47.300]                       }
[15:32:47.300]                       else if (inherits(cond, "condition")) {
[15:32:47.300]                         if (!is.null(pattern)) {
[15:32:47.300]                           computeRestarts <- base::computeRestarts
[15:32:47.300]                           grepl <- base::grepl
[15:32:47.300]                           restarts <- computeRestarts(cond)
[15:32:47.300]                           for (restart in restarts) {
[15:32:47.300]                             name <- restart$name
[15:32:47.300]                             if (is.null(name)) 
[15:32:47.300]                               next
[15:32:47.300]                             if (!grepl(pattern, name)) 
[15:32:47.300]                               next
[15:32:47.300]                             invokeRestart(restart)
[15:32:47.300]                             muffled <- TRUE
[15:32:47.300]                             break
[15:32:47.300]                           }
[15:32:47.300]                         }
[15:32:47.300]                       }
[15:32:47.300]                       invisible(muffled)
[15:32:47.300]                     }
[15:32:47.300]                     muffleCondition(cond, pattern = "^muffle")
[15:32:47.300]                   }
[15:32:47.300]                 }
[15:32:47.300]                 else {
[15:32:47.300]                   if (TRUE) {
[15:32:47.300]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.300]                     {
[15:32:47.300]                       inherits <- base::inherits
[15:32:47.300]                       invokeRestart <- base::invokeRestart
[15:32:47.300]                       is.null <- base::is.null
[15:32:47.300]                       muffled <- FALSE
[15:32:47.300]                       if (inherits(cond, "message")) {
[15:32:47.300]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:47.300]                         if (muffled) 
[15:32:47.300]                           invokeRestart("muffleMessage")
[15:32:47.300]                       }
[15:32:47.300]                       else if (inherits(cond, "warning")) {
[15:32:47.300]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:47.300]                         if (muffled) 
[15:32:47.300]                           invokeRestart("muffleWarning")
[15:32:47.300]                       }
[15:32:47.300]                       else if (inherits(cond, "condition")) {
[15:32:47.300]                         if (!is.null(pattern)) {
[15:32:47.300]                           computeRestarts <- base::computeRestarts
[15:32:47.300]                           grepl <- base::grepl
[15:32:47.300]                           restarts <- computeRestarts(cond)
[15:32:47.300]                           for (restart in restarts) {
[15:32:47.300]                             name <- restart$name
[15:32:47.300]                             if (is.null(name)) 
[15:32:47.300]                               next
[15:32:47.300]                             if (!grepl(pattern, name)) 
[15:32:47.300]                               next
[15:32:47.300]                             invokeRestart(restart)
[15:32:47.300]                             muffled <- TRUE
[15:32:47.300]                             break
[15:32:47.300]                           }
[15:32:47.300]                         }
[15:32:47.300]                       }
[15:32:47.300]                       invisible(muffled)
[15:32:47.300]                     }
[15:32:47.300]                     muffleCondition(cond, pattern = "^muffle")
[15:32:47.300]                   }
[15:32:47.300]                 }
[15:32:47.300]             }
[15:32:47.300]         }))
[15:32:47.300]     }, error = function(ex) {
[15:32:47.300]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:47.300]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:47.300]                 ...future.rng), started = ...future.startTime, 
[15:32:47.300]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:47.300]             version = "1.8"), class = "FutureResult")
[15:32:47.300]     }, finally = {
[15:32:47.300]         if (!identical(...future.workdir, getwd())) 
[15:32:47.300]             setwd(...future.workdir)
[15:32:47.300]         {
[15:32:47.300]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:47.300]                 ...future.oldOptions$nwarnings <- NULL
[15:32:47.300]             }
[15:32:47.300]             base::options(...future.oldOptions)
[15:32:47.300]             if (.Platform$OS.type == "windows") {
[15:32:47.300]                 old_names <- names(...future.oldEnvVars)
[15:32:47.300]                 envs <- base::Sys.getenv()
[15:32:47.300]                 names <- names(envs)
[15:32:47.300]                 common <- intersect(names, old_names)
[15:32:47.300]                 added <- setdiff(names, old_names)
[15:32:47.300]                 removed <- setdiff(old_names, names)
[15:32:47.300]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:47.300]                   envs[common]]
[15:32:47.300]                 NAMES <- toupper(changed)
[15:32:47.300]                 args <- list()
[15:32:47.300]                 for (kk in seq_along(NAMES)) {
[15:32:47.300]                   name <- changed[[kk]]
[15:32:47.300]                   NAME <- NAMES[[kk]]
[15:32:47.300]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.300]                     next
[15:32:47.300]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:47.300]                 }
[15:32:47.300]                 NAMES <- toupper(added)
[15:32:47.300]                 for (kk in seq_along(NAMES)) {
[15:32:47.300]                   name <- added[[kk]]
[15:32:47.300]                   NAME <- NAMES[[kk]]
[15:32:47.300]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.300]                     next
[15:32:47.300]                   args[[name]] <- ""
[15:32:47.300]                 }
[15:32:47.300]                 NAMES <- toupper(removed)
[15:32:47.300]                 for (kk in seq_along(NAMES)) {
[15:32:47.300]                   name <- removed[[kk]]
[15:32:47.300]                   NAME <- NAMES[[kk]]
[15:32:47.300]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.300]                     next
[15:32:47.300]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:47.300]                 }
[15:32:47.300]                 if (length(args) > 0) 
[15:32:47.300]                   base::do.call(base::Sys.setenv, args = args)
[15:32:47.300]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:47.300]             }
[15:32:47.300]             else {
[15:32:47.300]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:47.300]             }
[15:32:47.300]             {
[15:32:47.300]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:47.300]                   0L) {
[15:32:47.300]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:47.300]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:47.300]                   base::options(opts)
[15:32:47.300]                 }
[15:32:47.300]                 {
[15:32:47.300]                   {
[15:32:47.300]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:47.300]                     NULL
[15:32:47.300]                   }
[15:32:47.300]                   options(future.plan = NULL)
[15:32:47.300]                   if (is.na(NA_character_)) 
[15:32:47.300]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:47.300]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:47.300]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:47.300]                     .init = FALSE)
[15:32:47.300]                 }
[15:32:47.300]             }
[15:32:47.300]         }
[15:32:47.300]     })
[15:32:47.300]     if (TRUE) {
[15:32:47.300]         base::sink(type = "output", split = FALSE)
[15:32:47.300]         if (TRUE) {
[15:32:47.300]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:47.300]         }
[15:32:47.300]         else {
[15:32:47.300]             ...future.result["stdout"] <- base::list(NULL)
[15:32:47.300]         }
[15:32:47.300]         base::close(...future.stdout)
[15:32:47.300]         ...future.stdout <- NULL
[15:32:47.300]     }
[15:32:47.300]     ...future.result$conditions <- ...future.conditions
[15:32:47.300]     ...future.result$finished <- base::Sys.time()
[15:32:47.300]     ...future.result
[15:32:47.300] }
[15:32:47.311] Exporting 11 global objects (92.00 KiB) to cluster node #1 ...
[15:32:47.311] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:47.321] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:47.322] Exporting 'x_FUN' (56 bytes) to cluster node #1 ...
[15:32:47.323] Exporting 'x_FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:47.323] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:47.323] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:47.324] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:47.324] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:47.324] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:47.325] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:47.325] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:47.326] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:47.327] Exporting 'valid_types' (120 bytes) to cluster node #1 ...
[15:32:47.327] Exporting 'valid_types' (120 bytes) to cluster node #1 ... DONE
[15:32:47.328] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:47.329] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:47.329] Exporting '...future.elements_ii' (96 bytes) to cluster node #1 ...
[15:32:47.330] Exporting '...future.elements_ii' (96 bytes) to cluster node #1 ... DONE
[15:32:47.330] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:47.331] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:47.331] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:47.332] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:47.332] Exporting 11 global objects (92.00 KiB) to cluster node #1 ... DONE
[15:32:47.333] MultisessionFuture started
[15:32:47.333] - Launch lazy future ... done
[15:32:47.334] run() for 'MultisessionFuture' ... done
[15:32:47.334] Created future:
[15:32:47.363] receiveMessageFromWorker() for ClusterFuture ...
[15:32:47.363] - Validating connection of MultisessionFuture
[15:32:47.364] - received message: FutureResult
[15:32:47.364] - Received FutureResult
[15:32:47.364] - Erased future from FutureRegistry
[15:32:47.364] result() for ClusterFuture ...
[15:32:47.364] - result already collected: FutureResult
[15:32:47.365] result() for ClusterFuture ... done
[15:32:47.365] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:47.334] MultisessionFuture:
[15:32:47.334] Label: 'future_vapply-1'
[15:32:47.334] Expression:
[15:32:47.334] {
[15:32:47.334]     do.call(function(...) {
[15:32:47.334]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.334]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.334]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.334]             on.exit(options(oopts), add = TRUE)
[15:32:47.334]         }
[15:32:47.334]         {
[15:32:47.334]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.334]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.334]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.334]             })
[15:32:47.334]         }
[15:32:47.334]     }, args = future.call.arguments)
[15:32:47.334] }
[15:32:47.334] Lazy evaluation: FALSE
[15:32:47.334] Asynchronous evaluation: TRUE
[15:32:47.334] Local evaluation: TRUE
[15:32:47.334] Environment: R_GlobalEnv
[15:32:47.334] Capture standard output: TRUE
[15:32:47.334] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:47.334] Globals: 11 objects totaling 92.09 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 56 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:47.334] Packages: 1 packages ('future.apply')
[15:32:47.334] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:47.334] Resolved: TRUE
[15:32:47.334] Value: <not collected>
[15:32:47.334] Conditions captured: <none>
[15:32:47.334] Early signaling: FALSE
[15:32:47.334] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:47.334] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:47.365] Chunk #1 of 2 ... DONE
[15:32:47.365] Chunk #2 of 2 ...
[15:32:47.366]  - Finding globals in 'X' for chunk #2 ...
[15:32:47.366] getGlobalsAndPackages() ...
[15:32:47.366] Searching for globals...
[15:32:47.367] 
[15:32:47.367] Searching for globals ... DONE
[15:32:47.367] - globals: [0] <none>
[15:32:47.367] getGlobalsAndPackages() ... DONE
[15:32:47.367]    + additional globals found: [n=0] 
[15:32:47.368]    + additional namespaces needed: [n=0] 
[15:32:47.368]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:47.368]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:47.368]  - seeds: <none>
[15:32:47.368]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.369] getGlobalsAndPackages() ...
[15:32:47.369] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.369] Resolving globals: FALSE
[15:32:47.369] Tweak future expression to call with '...' arguments ...
[15:32:47.369] {
[15:32:47.369]     do.call(function(...) {
[15:32:47.369]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.369]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.369]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.369]             on.exit(options(oopts), add = TRUE)
[15:32:47.369]         }
[15:32:47.369]         {
[15:32:47.369]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.369]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.369]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.369]             })
[15:32:47.369]         }
[15:32:47.369]     }, args = future.call.arguments)
[15:32:47.369] }
[15:32:47.372] Tweak future expression to call with '...' arguments ... DONE
[15:32:47.374] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.374] - packages: [1] 'future.apply'
[15:32:47.374] getGlobalsAndPackages() ... DONE
[15:32:47.374] run() for 'Future' ...
[15:32:47.375] - state: 'created'
[15:32:47.375] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:47.393] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:47.394] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:47.394]   - Field: 'node'
[15:32:47.394]   - Field: 'label'
[15:32:47.394]   - Field: 'local'
[15:32:47.395]   - Field: 'owner'
[15:32:47.395]   - Field: 'envir'
[15:32:47.395]   - Field: 'workers'
[15:32:47.396]   - Field: 'packages'
[15:32:47.396]   - Field: 'gc'
[15:32:47.396]   - Field: 'conditions'
[15:32:47.396]   - Field: 'persistent'
[15:32:47.397]   - Field: 'expr'
[15:32:47.397]   - Field: 'uuid'
[15:32:47.397]   - Field: 'seed'
[15:32:47.398]   - Field: 'version'
[15:32:47.398]   - Field: 'result'
[15:32:47.398]   - Field: 'asynchronous'
[15:32:47.398]   - Field: 'calls'
[15:32:47.399]   - Field: 'globals'
[15:32:47.399]   - Field: 'stdout'
[15:32:47.399]   - Field: 'earlySignal'
[15:32:47.400]   - Field: 'lazy'
[15:32:47.400]   - Field: 'state'
[15:32:47.400] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:47.401] - Launch lazy future ...
[15:32:47.401] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:47.401] Packages needed by future strategies (n = 0): <none>
[15:32:47.402] {
[15:32:47.402]     {
[15:32:47.402]         {
[15:32:47.402]             ...future.startTime <- base::Sys.time()
[15:32:47.402]             {
[15:32:47.402]                 {
[15:32:47.402]                   {
[15:32:47.402]                     {
[15:32:47.402]                       {
[15:32:47.402]                         base::local({
[15:32:47.402]                           has_future <- base::requireNamespace("future", 
[15:32:47.402]                             quietly = TRUE)
[15:32:47.402]                           if (has_future) {
[15:32:47.402]                             ns <- base::getNamespace("future")
[15:32:47.402]                             version <- ns[[".package"]][["version"]]
[15:32:47.402]                             if (is.null(version)) 
[15:32:47.402]                               version <- utils::packageVersion("future")
[15:32:47.402]                           }
[15:32:47.402]                           else {
[15:32:47.402]                             version <- NULL
[15:32:47.402]                           }
[15:32:47.402]                           if (!has_future || version < "1.8.0") {
[15:32:47.402]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:47.402]                               "", base::R.version$version.string), 
[15:32:47.402]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:47.402]                                 base::R.version$platform, 8 * 
[15:32:47.402]                                   base::.Machine$sizeof.pointer), 
[15:32:47.402]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:47.402]                                 "release", "version")], collapse = " "), 
[15:32:47.402]                               hostname = base::Sys.info()[["nodename"]])
[15:32:47.402]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:47.402]                               info)
[15:32:47.402]                             info <- base::paste(info, collapse = "; ")
[15:32:47.402]                             if (!has_future) {
[15:32:47.402]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:47.402]                                 info)
[15:32:47.402]                             }
[15:32:47.402]                             else {
[15:32:47.402]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:47.402]                                 info, version)
[15:32:47.402]                             }
[15:32:47.402]                             base::stop(msg)
[15:32:47.402]                           }
[15:32:47.402]                         })
[15:32:47.402]                       }
[15:32:47.402]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:47.402]                       base::options(mc.cores = 1L)
[15:32:47.402]                     }
[15:32:47.402]                     base::local({
[15:32:47.402]                       for (pkg in "future.apply") {
[15:32:47.402]                         base::loadNamespace(pkg)
[15:32:47.402]                         base::library(pkg, character.only = TRUE)
[15:32:47.402]                       }
[15:32:47.402]                     })
[15:32:47.402]                   }
[15:32:47.402]                   ...future.strategy.old <- future::plan("list")
[15:32:47.402]                   options(future.plan = NULL)
[15:32:47.402]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:47.402]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:47.402]                 }
[15:32:47.402]                 ...future.workdir <- getwd()
[15:32:47.402]             }
[15:32:47.402]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:47.402]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:47.402]         }
[15:32:47.402]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:47.402]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:47.402]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:47.402]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:47.402]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:47.402]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:47.402]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:47.402]             base::names(...future.oldOptions))
[15:32:47.402]     }
[15:32:47.402]     if (FALSE) {
[15:32:47.402]     }
[15:32:47.402]     else {
[15:32:47.402]         if (TRUE) {
[15:32:47.402]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:47.402]                 open = "w")
[15:32:47.402]         }
[15:32:47.402]         else {
[15:32:47.402]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:47.402]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:47.402]         }
[15:32:47.402]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:47.402]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:47.402]             base::sink(type = "output", split = FALSE)
[15:32:47.402]             base::close(...future.stdout)
[15:32:47.402]         }, add = TRUE)
[15:32:47.402]     }
[15:32:47.402]     ...future.frame <- base::sys.nframe()
[15:32:47.402]     ...future.conditions <- base::list()
[15:32:47.402]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:47.402]     if (FALSE) {
[15:32:47.402]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:47.402]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:47.402]     }
[15:32:47.402]     ...future.result <- base::tryCatch({
[15:32:47.402]         base::withCallingHandlers({
[15:32:47.402]             ...future.value <- base::withVisible(base::local({
[15:32:47.402]                 ...future.makeSendCondition <- base::local({
[15:32:47.402]                   sendCondition <- NULL
[15:32:47.402]                   function(frame = 1L) {
[15:32:47.402]                     if (is.function(sendCondition)) 
[15:32:47.402]                       return(sendCondition)
[15:32:47.402]                     ns <- getNamespace("parallel")
[15:32:47.402]                     if (exists("sendData", mode = "function", 
[15:32:47.402]                       envir = ns)) {
[15:32:47.402]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:47.402]                         envir = ns)
[15:32:47.402]                       envir <- sys.frame(frame)
[15:32:47.402]                       master <- NULL
[15:32:47.402]                       while (!identical(envir, .GlobalEnv) && 
[15:32:47.402]                         !identical(envir, emptyenv())) {
[15:32:47.402]                         if (exists("master", mode = "list", envir = envir, 
[15:32:47.402]                           inherits = FALSE)) {
[15:32:47.402]                           master <- get("master", mode = "list", 
[15:32:47.402]                             envir = envir, inherits = FALSE)
[15:32:47.402]                           if (inherits(master, c("SOCKnode", 
[15:32:47.402]                             "SOCK0node"))) {
[15:32:47.402]                             sendCondition <<- function(cond) {
[15:32:47.402]                               data <- list(type = "VALUE", value = cond, 
[15:32:47.402]                                 success = TRUE)
[15:32:47.402]                               parallel_sendData(master, data)
[15:32:47.402]                             }
[15:32:47.402]                             return(sendCondition)
[15:32:47.402]                           }
[15:32:47.402]                         }
[15:32:47.402]                         frame <- frame + 1L
[15:32:47.402]                         envir <- sys.frame(frame)
[15:32:47.402]                       }
[15:32:47.402]                     }
[15:32:47.402]                     sendCondition <<- function(cond) NULL
[15:32:47.402]                   }
[15:32:47.402]                 })
[15:32:47.402]                 withCallingHandlers({
[15:32:47.402]                   {
[15:32:47.402]                     do.call(function(...) {
[15:32:47.402]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.402]                       if (!identical(...future.globals.maxSize.org, 
[15:32:47.402]                         ...future.globals.maxSize)) {
[15:32:47.402]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.402]                         on.exit(options(oopts), add = TRUE)
[15:32:47.402]                       }
[15:32:47.402]                       {
[15:32:47.402]                         lapply(seq_along(...future.elements_ii), 
[15:32:47.402]                           FUN = function(jj) {
[15:32:47.402]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.402]                             ...future.FUN(...future.X_jj, ...)
[15:32:47.402]                           })
[15:32:47.402]                       }
[15:32:47.402]                     }, args = future.call.arguments)
[15:32:47.402]                   }
[15:32:47.402]                 }, immediateCondition = function(cond) {
[15:32:47.402]                   sendCondition <- ...future.makeSendCondition()
[15:32:47.402]                   sendCondition(cond)
[15:32:47.402]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.402]                   {
[15:32:47.402]                     inherits <- base::inherits
[15:32:47.402]                     invokeRestart <- base::invokeRestart
[15:32:47.402]                     is.null <- base::is.null
[15:32:47.402]                     muffled <- FALSE
[15:32:47.402]                     if (inherits(cond, "message")) {
[15:32:47.402]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:47.402]                       if (muffled) 
[15:32:47.402]                         invokeRestart("muffleMessage")
[15:32:47.402]                     }
[15:32:47.402]                     else if (inherits(cond, "warning")) {
[15:32:47.402]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:47.402]                       if (muffled) 
[15:32:47.402]                         invokeRestart("muffleWarning")
[15:32:47.402]                     }
[15:32:47.402]                     else if (inherits(cond, "condition")) {
[15:32:47.402]                       if (!is.null(pattern)) {
[15:32:47.402]                         computeRestarts <- base::computeRestarts
[15:32:47.402]                         grepl <- base::grepl
[15:32:47.402]                         restarts <- computeRestarts(cond)
[15:32:47.402]                         for (restart in restarts) {
[15:32:47.402]                           name <- restart$name
[15:32:47.402]                           if (is.null(name)) 
[15:32:47.402]                             next
[15:32:47.402]                           if (!grepl(pattern, name)) 
[15:32:47.402]                             next
[15:32:47.402]                           invokeRestart(restart)
[15:32:47.402]                           muffled <- TRUE
[15:32:47.402]                           break
[15:32:47.402]                         }
[15:32:47.402]                       }
[15:32:47.402]                     }
[15:32:47.402]                     invisible(muffled)
[15:32:47.402]                   }
[15:32:47.402]                   muffleCondition(cond)
[15:32:47.402]                 })
[15:32:47.402]             }))
[15:32:47.402]             future::FutureResult(value = ...future.value$value, 
[15:32:47.402]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:47.402]                   ...future.rng), globalenv = if (FALSE) 
[15:32:47.402]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:47.402]                     ...future.globalenv.names))
[15:32:47.402]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:47.402]         }, condition = base::local({
[15:32:47.402]             c <- base::c
[15:32:47.402]             inherits <- base::inherits
[15:32:47.402]             invokeRestart <- base::invokeRestart
[15:32:47.402]             length <- base::length
[15:32:47.402]             list <- base::list
[15:32:47.402]             seq.int <- base::seq.int
[15:32:47.402]             signalCondition <- base::signalCondition
[15:32:47.402]             sys.calls <- base::sys.calls
[15:32:47.402]             `[[` <- base::`[[`
[15:32:47.402]             `+` <- base::`+`
[15:32:47.402]             `<<-` <- base::`<<-`
[15:32:47.402]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:47.402]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:47.402]                   3L)]
[15:32:47.402]             }
[15:32:47.402]             function(cond) {
[15:32:47.402]                 is_error <- inherits(cond, "error")
[15:32:47.402]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:47.402]                   NULL)
[15:32:47.402]                 if (is_error) {
[15:32:47.402]                   sessionInformation <- function() {
[15:32:47.402]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:47.402]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:47.402]                       search = base::search(), system = base::Sys.info())
[15:32:47.402]                   }
[15:32:47.402]                   ...future.conditions[[length(...future.conditions) + 
[15:32:47.402]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:47.402]                     cond$call), session = sessionInformation(), 
[15:32:47.402]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:47.402]                   signalCondition(cond)
[15:32:47.402]                 }
[15:32:47.402]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:47.402]                 "immediateCondition"))) {
[15:32:47.402]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:47.402]                   ...future.conditions[[length(...future.conditions) + 
[15:32:47.402]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:47.402]                   if (TRUE && !signal) {
[15:32:47.402]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.402]                     {
[15:32:47.402]                       inherits <- base::inherits
[15:32:47.402]                       invokeRestart <- base::invokeRestart
[15:32:47.402]                       is.null <- base::is.null
[15:32:47.402]                       muffled <- FALSE
[15:32:47.402]                       if (inherits(cond, "message")) {
[15:32:47.402]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:47.402]                         if (muffled) 
[15:32:47.402]                           invokeRestart("muffleMessage")
[15:32:47.402]                       }
[15:32:47.402]                       else if (inherits(cond, "warning")) {
[15:32:47.402]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:47.402]                         if (muffled) 
[15:32:47.402]                           invokeRestart("muffleWarning")
[15:32:47.402]                       }
[15:32:47.402]                       else if (inherits(cond, "condition")) {
[15:32:47.402]                         if (!is.null(pattern)) {
[15:32:47.402]                           computeRestarts <- base::computeRestarts
[15:32:47.402]                           grepl <- base::grepl
[15:32:47.402]                           restarts <- computeRestarts(cond)
[15:32:47.402]                           for (restart in restarts) {
[15:32:47.402]                             name <- restart$name
[15:32:47.402]                             if (is.null(name)) 
[15:32:47.402]                               next
[15:32:47.402]                             if (!grepl(pattern, name)) 
[15:32:47.402]                               next
[15:32:47.402]                             invokeRestart(restart)
[15:32:47.402]                             muffled <- TRUE
[15:32:47.402]                             break
[15:32:47.402]                           }
[15:32:47.402]                         }
[15:32:47.402]                       }
[15:32:47.402]                       invisible(muffled)
[15:32:47.402]                     }
[15:32:47.402]                     muffleCondition(cond, pattern = "^muffle")
[15:32:47.402]                   }
[15:32:47.402]                 }
[15:32:47.402]                 else {
[15:32:47.402]                   if (TRUE) {
[15:32:47.402]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.402]                     {
[15:32:47.402]                       inherits <- base::inherits
[15:32:47.402]                       invokeRestart <- base::invokeRestart
[15:32:47.402]                       is.null <- base::is.null
[15:32:47.402]                       muffled <- FALSE
[15:32:47.402]                       if (inherits(cond, "message")) {
[15:32:47.402]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:47.402]                         if (muffled) 
[15:32:47.402]                           invokeRestart("muffleMessage")
[15:32:47.402]                       }
[15:32:47.402]                       else if (inherits(cond, "warning")) {
[15:32:47.402]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:47.402]                         if (muffled) 
[15:32:47.402]                           invokeRestart("muffleWarning")
[15:32:47.402]                       }
[15:32:47.402]                       else if (inherits(cond, "condition")) {
[15:32:47.402]                         if (!is.null(pattern)) {
[15:32:47.402]                           computeRestarts <- base::computeRestarts
[15:32:47.402]                           grepl <- base::grepl
[15:32:47.402]                           restarts <- computeRestarts(cond)
[15:32:47.402]                           for (restart in restarts) {
[15:32:47.402]                             name <- restart$name
[15:32:47.402]                             if (is.null(name)) 
[15:32:47.402]                               next
[15:32:47.402]                             if (!grepl(pattern, name)) 
[15:32:47.402]                               next
[15:32:47.402]                             invokeRestart(restart)
[15:32:47.402]                             muffled <- TRUE
[15:32:47.402]                             break
[15:32:47.402]                           }
[15:32:47.402]                         }
[15:32:47.402]                       }
[15:32:47.402]                       invisible(muffled)
[15:32:47.402]                     }
[15:32:47.402]                     muffleCondition(cond, pattern = "^muffle")
[15:32:47.402]                   }
[15:32:47.402]                 }
[15:32:47.402]             }
[15:32:47.402]         }))
[15:32:47.402]     }, error = function(ex) {
[15:32:47.402]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:47.402]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:47.402]                 ...future.rng), started = ...future.startTime, 
[15:32:47.402]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:47.402]             version = "1.8"), class = "FutureResult")
[15:32:47.402]     }, finally = {
[15:32:47.402]         if (!identical(...future.workdir, getwd())) 
[15:32:47.402]             setwd(...future.workdir)
[15:32:47.402]         {
[15:32:47.402]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:47.402]                 ...future.oldOptions$nwarnings <- NULL
[15:32:47.402]             }
[15:32:47.402]             base::options(...future.oldOptions)
[15:32:47.402]             if (.Platform$OS.type == "windows") {
[15:32:47.402]                 old_names <- names(...future.oldEnvVars)
[15:32:47.402]                 envs <- base::Sys.getenv()
[15:32:47.402]                 names <- names(envs)
[15:32:47.402]                 common <- intersect(names, old_names)
[15:32:47.402]                 added <- setdiff(names, old_names)
[15:32:47.402]                 removed <- setdiff(old_names, names)
[15:32:47.402]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:47.402]                   envs[common]]
[15:32:47.402]                 NAMES <- toupper(changed)
[15:32:47.402]                 args <- list()
[15:32:47.402]                 for (kk in seq_along(NAMES)) {
[15:32:47.402]                   name <- changed[[kk]]
[15:32:47.402]                   NAME <- NAMES[[kk]]
[15:32:47.402]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.402]                     next
[15:32:47.402]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:47.402]                 }
[15:32:47.402]                 NAMES <- toupper(added)
[15:32:47.402]                 for (kk in seq_along(NAMES)) {
[15:32:47.402]                   name <- added[[kk]]
[15:32:47.402]                   NAME <- NAMES[[kk]]
[15:32:47.402]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.402]                     next
[15:32:47.402]                   args[[name]] <- ""
[15:32:47.402]                 }
[15:32:47.402]                 NAMES <- toupper(removed)
[15:32:47.402]                 for (kk in seq_along(NAMES)) {
[15:32:47.402]                   name <- removed[[kk]]
[15:32:47.402]                   NAME <- NAMES[[kk]]
[15:32:47.402]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.402]                     next
[15:32:47.402]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:47.402]                 }
[15:32:47.402]                 if (length(args) > 0) 
[15:32:47.402]                   base::do.call(base::Sys.setenv, args = args)
[15:32:47.402]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:47.402]             }
[15:32:47.402]             else {
[15:32:47.402]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:47.402]             }
[15:32:47.402]             {
[15:32:47.402]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:47.402]                   0L) {
[15:32:47.402]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:47.402]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:47.402]                   base::options(opts)
[15:32:47.402]                 }
[15:32:47.402]                 {
[15:32:47.402]                   {
[15:32:47.402]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:47.402]                     NULL
[15:32:47.402]                   }
[15:32:47.402]                   options(future.plan = NULL)
[15:32:47.402]                   if (is.na(NA_character_)) 
[15:32:47.402]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:47.402]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:47.402]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:47.402]                     .init = FALSE)
[15:32:47.402]                 }
[15:32:47.402]             }
[15:32:47.402]         }
[15:32:47.402]     })
[15:32:47.402]     if (TRUE) {
[15:32:47.402]         base::sink(type = "output", split = FALSE)
[15:32:47.402]         if (TRUE) {
[15:32:47.402]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:47.402]         }
[15:32:47.402]         else {
[15:32:47.402]             ...future.result["stdout"] <- base::list(NULL)
[15:32:47.402]         }
[15:32:47.402]         base::close(...future.stdout)
[15:32:47.402]         ...future.stdout <- NULL
[15:32:47.402]     }
[15:32:47.402]     ...future.result$conditions <- ...future.conditions
[15:32:47.402]     ...future.result$finished <- base::Sys.time()
[15:32:47.402]     ...future.result
[15:32:47.402] }
[15:32:47.412] Exporting 11 global objects (92.00 KiB) to cluster node #1 ...
[15:32:47.412] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:47.413] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:47.414] Exporting 'x_FUN' (56 bytes) to cluster node #1 ...
[15:32:47.414] Exporting 'x_FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:47.415] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:47.415] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:47.416] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:47.417] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:47.417] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:47.418] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:47.419] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:47.420] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:47.420] Exporting 'valid_types' (120 bytes) to cluster node #1 ...
[15:32:47.421] Exporting 'valid_types' (120 bytes) to cluster node #1 ... DONE
[15:32:47.421] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:47.422] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:47.423] Exporting '...future.elements_ii' (736 bytes) to cluster node #1 ...
[15:32:47.423] Exporting '...future.elements_ii' (736 bytes) to cluster node #1 ... DONE
[15:32:47.424] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:47.424] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:47.424] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:47.425] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:47.426] Exporting 11 global objects (92.00 KiB) to cluster node #1 ... DONE
[15:32:47.427] MultisessionFuture started
[15:32:47.427] - Launch lazy future ... done
[15:32:47.428] run() for 'MultisessionFuture' ... done
[15:32:47.428] Created future:
[15:32:47.464] receiveMessageFromWorker() for ClusterFuture ...
[15:32:47.465] - Validating connection of MultisessionFuture
[15:32:47.465] - received message: FutureResult
[15:32:47.466] - Received FutureResult
[15:32:47.466] - Erased future from FutureRegistry
[15:32:47.466] result() for ClusterFuture ...
[15:32:47.467] - result already collected: FutureResult
[15:32:47.467] result() for ClusterFuture ... done
[15:32:47.467] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:47.428] MultisessionFuture:
[15:32:47.428] Label: 'future_vapply-2'
[15:32:47.428] Expression:
[15:32:47.428] {
[15:32:47.428]     do.call(function(...) {
[15:32:47.428]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.428]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.428]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.428]             on.exit(options(oopts), add = TRUE)
[15:32:47.428]         }
[15:32:47.428]         {
[15:32:47.428]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.428]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.428]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.428]             })
[15:32:47.428]         }
[15:32:47.428]     }, args = future.call.arguments)
[15:32:47.428] }
[15:32:47.428] Lazy evaluation: FALSE
[15:32:47.428] Asynchronous evaluation: TRUE
[15:32:47.428] Local evaluation: TRUE
[15:32:47.428] Environment: R_GlobalEnv
[15:32:47.428] Capture standard output: TRUE
[15:32:47.428] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:47.428] Globals: 11 objects totaling 92.72 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 56 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:47.428] Packages: 1 packages ('future.apply')
[15:32:47.428] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:47.428] Resolved: TRUE
[15:32:47.428] Value: <not collected>
[15:32:47.428] Conditions captured: <none>
[15:32:47.428] Early signaling: FALSE
[15:32:47.428] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:47.428] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:47.468] Chunk #2 of 2 ... DONE
[15:32:47.468] Launching 2 futures (chunks) ... DONE
[15:32:47.469] Resolving 2 futures (chunks) ...
[15:32:47.469] resolve() on list ...
[15:32:47.469]  recursive: 0
[15:32:47.469]  length: 2
[15:32:47.470] 
[15:32:47.470] Future #1
[15:32:47.470] result() for ClusterFuture ...
[15:32:47.470] - result already collected: FutureResult
[15:32:47.471] result() for ClusterFuture ... done
[15:32:47.471] result() for ClusterFuture ...
[15:32:47.471] - result already collected: FutureResult
[15:32:47.471] result() for ClusterFuture ... done
[15:32:47.472] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:47.472] - nx: 2
[15:32:47.472] - relay: TRUE
[15:32:47.472] - stdout: TRUE
[15:32:47.472] - signal: TRUE
[15:32:47.473] - resignal: FALSE
[15:32:47.473] - force: TRUE
[15:32:47.473] - relayed: [n=2] FALSE, FALSE
[15:32:47.473] - queued futures: [n=2] FALSE, FALSE
[15:32:47.474]  - until=1
[15:32:47.474]  - relaying element #1
[15:32:47.474] result() for ClusterFuture ...
[15:32:47.474] - result already collected: FutureResult
[15:32:47.475] result() for ClusterFuture ... done
[15:32:47.475] result() for ClusterFuture ...
[15:32:47.475] - result already collected: FutureResult
[15:32:47.475] result() for ClusterFuture ... done
[15:32:47.476] result() for ClusterFuture ...
[15:32:47.476] - result already collected: FutureResult
[15:32:47.476] result() for ClusterFuture ... done
[15:32:47.476] result() for ClusterFuture ...
[15:32:47.477] - result already collected: FutureResult
[15:32:47.477] result() for ClusterFuture ... done
[15:32:47.477] - relayed: [n=2] TRUE, FALSE
[15:32:47.477] - queued futures: [n=2] TRUE, FALSE
[15:32:47.478] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:47.478]  length: 1 (resolved future 1)
[15:32:47.478] Future #2
[15:32:47.478] result() for ClusterFuture ...
[15:32:47.479] - result already collected: FutureResult
[15:32:47.479] result() for ClusterFuture ... done
[15:32:47.479] result() for ClusterFuture ...
[15:32:47.479] - result already collected: FutureResult
[15:32:47.479] result() for ClusterFuture ... done
[15:32:47.480] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:47.480] - nx: 2
[15:32:47.480] - relay: TRUE
[15:32:47.480] - stdout: TRUE
[15:32:47.481] - signal: TRUE
[15:32:47.481] - resignal: FALSE
[15:32:47.481] - force: TRUE
[15:32:47.481] - relayed: [n=2] TRUE, FALSE
[15:32:47.482] - queued futures: [n=2] TRUE, FALSE
[15:32:47.482]  - until=2
[15:32:47.482]  - relaying element #2
[15:32:47.483] result() for ClusterFuture ...
[15:32:47.483] - result already collected: FutureResult
[15:32:47.483] result() for ClusterFuture ... done
[15:32:47.483] result() for ClusterFuture ...
[15:32:47.483] - result already collected: FutureResult
[15:32:47.484] result() for ClusterFuture ... done
[15:32:47.484] result() for ClusterFuture ...
[15:32:47.484] - result already collected: FutureResult
[15:32:47.485] result() for ClusterFuture ... done
[15:32:47.485] result() for ClusterFuture ...
[15:32:47.485] - result already collected: FutureResult
[15:32:47.485] result() for ClusterFuture ... done
[15:32:47.485] - relayed: [n=2] TRUE, TRUE
[15:32:47.486] - queued futures: [n=2] TRUE, TRUE
[15:32:47.486] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:47.486]  length: 0 (resolved future 2)
[15:32:47.487] Relaying remaining futures
[15:32:47.487] signalConditionsASAP(NULL, pos=0) ...
[15:32:47.487] - nx: 2
[15:32:47.487] - relay: TRUE
[15:32:47.487] - stdout: TRUE
[15:32:47.488] - signal: TRUE
[15:32:47.488] - resignal: FALSE
[15:32:47.488] - force: TRUE
[15:32:47.488] - relayed: [n=2] TRUE, TRUE
[15:32:47.489] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:47.489] - relayed: [n=2] TRUE, TRUE
[15:32:47.489] - queued futures: [n=2] TRUE, TRUE
[15:32:47.489] signalConditionsASAP(NULL, pos=0) ... done
[15:32:47.490] resolve() on list ... DONE
[15:32:47.490] result() for ClusterFuture ...
[15:32:47.490] - result already collected: FutureResult
[15:32:47.490] result() for ClusterFuture ... done
[15:32:47.491] result() for ClusterFuture ...
[15:32:47.491] - result already collected: FutureResult
[15:32:47.491] result() for ClusterFuture ... done
[15:32:47.491] result() for ClusterFuture ...
[15:32:47.492] - result already collected: FutureResult
[15:32:47.492] result() for ClusterFuture ... done
[15:32:47.492] result() for ClusterFuture ...
[15:32:47.492] - result already collected: FutureResult
[15:32:47.493] result() for ClusterFuture ... done
[15:32:47.493]  - Number of value chunks collected: 2
[15:32:47.493] Resolving 2 futures (chunks) ... DONE
[15:32:47.493] Reducing values from 2 chunks ...
[15:32:47.494]  - Number of values collected after concatenation: 2
[15:32:47.494]  - Number of values expected: 2
[15:32:47.494] Reducing values from 2 chunks ... DONE
[15:32:47.494] future_lapply() ... DONE
 Named chr [1:2] "integer" "character"
 - attr(*, "names")= chr [1:2] "x" "y"
 num[0 , 1:10] 
[15:32:47.496] future_lapply() ...
[15:32:47.503] Number of chunks: 2
[15:32:47.504] getGlobalsAndPackagesXApply() ...
[15:32:47.504]  - future.globals: TRUE
[15:32:47.504] getGlobalsAndPackages() ...
[15:32:47.505] Searching for globals...
[15:32:47.511] - globals found: [17] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'double'
[15:32:47.512] Searching for globals ... DONE
[15:32:47.512] Resolving globals: FALSE
[15:32:47.514] The total size of the 7 globals is 93.23 KiB (95472 bytes)
[15:32:47.514] The total size of the 7 globals exported for future expression ('FUN()') is 93.23 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:47.515] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:47.515] - packages: [1] 'future.apply'
[15:32:47.515] getGlobalsAndPackages() ... DONE
[15:32:47.516]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:47.516]  - needed namespaces: [n=1] 'future.apply'
[15:32:47.516] Finding globals ... DONE
[15:32:47.517]  - use_args: TRUE
[15:32:47.517]  - Getting '...' globals ...
[15:32:47.518] resolve() on list ...
[15:32:47.518]  recursive: 0
[15:32:47.518]  length: 1
[15:32:47.518]  elements: '...'
[15:32:47.519]  length: 0 (resolved future 1)
[15:32:47.519] resolve() on list ... DONE
[15:32:47.519]    - '...' content: [n=0] 
[15:32:47.519] List of 1
[15:32:47.519]  $ ...: list()
[15:32:47.519]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:47.519]  - attr(*, "where")=List of 1
[15:32:47.519]   ..$ ...:<environment: 0x0000022d405376f0> 
[15:32:47.519]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:47.519]  - attr(*, "resolved")= logi TRUE
[15:32:47.519]  - attr(*, "total_size")= num NA
[15:32:47.524]  - Getting '...' globals ... DONE
[15:32:47.525] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:47.525] List of 8
[15:32:47.525]  $ ...future.FUN:function (x, ...)  
[15:32:47.525]  $ x_FUN        :function (x)  
[15:32:47.525]  $ times        : int 0
[15:32:47.525]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:47.525]  $ stop_if_not  :function (...)  
[15:32:47.525]  $ dim          : NULL
[15:32:47.525]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:47.525]  $ ...          : list()
[15:32:47.525]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:47.525]  - attr(*, "where")=List of 8
[15:32:47.525]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:47.525]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:47.525]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:47.525]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:47.525]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:47.525]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:47.525]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:47.525]   ..$ ...          :<environment: 0x0000022d405376f0> 
[15:32:47.525]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:47.525]  - attr(*, "resolved")= logi FALSE
[15:32:47.525]  - attr(*, "total_size")= num 95472
[15:32:47.535] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:47.535] getGlobalsAndPackagesXApply() ... DONE
[15:32:47.535] Number of futures (= number of chunks): 2
[15:32:47.536] Launching 2 futures (chunks) ...
[15:32:47.536] Chunk #1 of 2 ...
[15:32:47.536]  - Finding globals in 'X' for chunk #1 ...
[15:32:47.536] getGlobalsAndPackages() ...
[15:32:47.537] Searching for globals...
[15:32:47.537] 
[15:32:47.537] Searching for globals ... DONE
[15:32:47.538] - globals: [0] <none>
[15:32:47.538] getGlobalsAndPackages() ... DONE
[15:32:47.538]    + additional globals found: [n=0] 
[15:32:47.538]    + additional namespaces needed: [n=0] 
[15:32:47.539]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:47.539]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:47.539]  - seeds: <none>
[15:32:47.539]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.540] getGlobalsAndPackages() ...
[15:32:47.540] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.540] Resolving globals: FALSE
[15:32:47.540] Tweak future expression to call with '...' arguments ...
[15:32:47.541] {
[15:32:47.541]     do.call(function(...) {
[15:32:47.541]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.541]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.541]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.541]             on.exit(options(oopts), add = TRUE)
[15:32:47.541]         }
[15:32:47.541]         {
[15:32:47.541]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.541]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.541]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.541]             })
[15:32:47.541]         }
[15:32:47.541]     }, args = future.call.arguments)
[15:32:47.541] }
[15:32:47.541] Tweak future expression to call with '...' arguments ... DONE
[15:32:47.543] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.543] - packages: [1] 'future.apply'
[15:32:47.543] getGlobalsAndPackages() ... DONE
[15:32:47.544] run() for 'Future' ...
[15:32:47.544] - state: 'created'
[15:32:47.544] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:47.560] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:47.561] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:47.561]   - Field: 'node'
[15:32:47.561]   - Field: 'label'
[15:32:47.562]   - Field: 'local'
[15:32:47.562]   - Field: 'owner'
[15:32:47.562]   - Field: 'envir'
[15:32:47.562]   - Field: 'workers'
[15:32:47.563]   - Field: 'packages'
[15:32:47.563]   - Field: 'gc'
[15:32:47.563]   - Field: 'conditions'
[15:32:47.563]   - Field: 'persistent'
[15:32:47.564]   - Field: 'expr'
[15:32:47.564]   - Field: 'uuid'
[15:32:47.564]   - Field: 'seed'
[15:32:47.565]   - Field: 'version'
[15:32:47.565]   - Field: 'result'
[15:32:47.565]   - Field: 'asynchronous'
[15:32:47.565]   - Field: 'calls'
[15:32:47.566]   - Field: 'globals'
[15:32:47.566]   - Field: 'stdout'
[15:32:47.566]   - Field: 'earlySignal'
[15:32:47.566]   - Field: 'lazy'
[15:32:47.567]   - Field: 'state'
[15:32:47.567] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:47.567] - Launch lazy future ...
[15:32:47.568] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:47.568] Packages needed by future strategies (n = 0): <none>
[15:32:47.569] {
[15:32:47.569]     {
[15:32:47.569]         {
[15:32:47.569]             ...future.startTime <- base::Sys.time()
[15:32:47.569]             {
[15:32:47.569]                 {
[15:32:47.569]                   {
[15:32:47.569]                     {
[15:32:47.569]                       {
[15:32:47.569]                         base::local({
[15:32:47.569]                           has_future <- base::requireNamespace("future", 
[15:32:47.569]                             quietly = TRUE)
[15:32:47.569]                           if (has_future) {
[15:32:47.569]                             ns <- base::getNamespace("future")
[15:32:47.569]                             version <- ns[[".package"]][["version"]]
[15:32:47.569]                             if (is.null(version)) 
[15:32:47.569]                               version <- utils::packageVersion("future")
[15:32:47.569]                           }
[15:32:47.569]                           else {
[15:32:47.569]                             version <- NULL
[15:32:47.569]                           }
[15:32:47.569]                           if (!has_future || version < "1.8.0") {
[15:32:47.569]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:47.569]                               "", base::R.version$version.string), 
[15:32:47.569]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:47.569]                                 base::R.version$platform, 8 * 
[15:32:47.569]                                   base::.Machine$sizeof.pointer), 
[15:32:47.569]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:47.569]                                 "release", "version")], collapse = " "), 
[15:32:47.569]                               hostname = base::Sys.info()[["nodename"]])
[15:32:47.569]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:47.569]                               info)
[15:32:47.569]                             info <- base::paste(info, collapse = "; ")
[15:32:47.569]                             if (!has_future) {
[15:32:47.569]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:47.569]                                 info)
[15:32:47.569]                             }
[15:32:47.569]                             else {
[15:32:47.569]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:47.569]                                 info, version)
[15:32:47.569]                             }
[15:32:47.569]                             base::stop(msg)
[15:32:47.569]                           }
[15:32:47.569]                         })
[15:32:47.569]                       }
[15:32:47.569]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:47.569]                       base::options(mc.cores = 1L)
[15:32:47.569]                     }
[15:32:47.569]                     base::local({
[15:32:47.569]                       for (pkg in "future.apply") {
[15:32:47.569]                         base::loadNamespace(pkg)
[15:32:47.569]                         base::library(pkg, character.only = TRUE)
[15:32:47.569]                       }
[15:32:47.569]                     })
[15:32:47.569]                   }
[15:32:47.569]                   ...future.strategy.old <- future::plan("list")
[15:32:47.569]                   options(future.plan = NULL)
[15:32:47.569]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:47.569]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:47.569]                 }
[15:32:47.569]                 ...future.workdir <- getwd()
[15:32:47.569]             }
[15:32:47.569]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:47.569]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:47.569]         }
[15:32:47.569]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:47.569]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:47.569]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:47.569]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:47.569]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:47.569]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:47.569]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:47.569]             base::names(...future.oldOptions))
[15:32:47.569]     }
[15:32:47.569]     if (FALSE) {
[15:32:47.569]     }
[15:32:47.569]     else {
[15:32:47.569]         if (TRUE) {
[15:32:47.569]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:47.569]                 open = "w")
[15:32:47.569]         }
[15:32:47.569]         else {
[15:32:47.569]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:47.569]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:47.569]         }
[15:32:47.569]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:47.569]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:47.569]             base::sink(type = "output", split = FALSE)
[15:32:47.569]             base::close(...future.stdout)
[15:32:47.569]         }, add = TRUE)
[15:32:47.569]     }
[15:32:47.569]     ...future.frame <- base::sys.nframe()
[15:32:47.569]     ...future.conditions <- base::list()
[15:32:47.569]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:47.569]     if (FALSE) {
[15:32:47.569]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:47.569]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:47.569]     }
[15:32:47.569]     ...future.result <- base::tryCatch({
[15:32:47.569]         base::withCallingHandlers({
[15:32:47.569]             ...future.value <- base::withVisible(base::local({
[15:32:47.569]                 ...future.makeSendCondition <- base::local({
[15:32:47.569]                   sendCondition <- NULL
[15:32:47.569]                   function(frame = 1L) {
[15:32:47.569]                     if (is.function(sendCondition)) 
[15:32:47.569]                       return(sendCondition)
[15:32:47.569]                     ns <- getNamespace("parallel")
[15:32:47.569]                     if (exists("sendData", mode = "function", 
[15:32:47.569]                       envir = ns)) {
[15:32:47.569]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:47.569]                         envir = ns)
[15:32:47.569]                       envir <- sys.frame(frame)
[15:32:47.569]                       master <- NULL
[15:32:47.569]                       while (!identical(envir, .GlobalEnv) && 
[15:32:47.569]                         !identical(envir, emptyenv())) {
[15:32:47.569]                         if (exists("master", mode = "list", envir = envir, 
[15:32:47.569]                           inherits = FALSE)) {
[15:32:47.569]                           master <- get("master", mode = "list", 
[15:32:47.569]                             envir = envir, inherits = FALSE)
[15:32:47.569]                           if (inherits(master, c("SOCKnode", 
[15:32:47.569]                             "SOCK0node"))) {
[15:32:47.569]                             sendCondition <<- function(cond) {
[15:32:47.569]                               data <- list(type = "VALUE", value = cond, 
[15:32:47.569]                                 success = TRUE)
[15:32:47.569]                               parallel_sendData(master, data)
[15:32:47.569]                             }
[15:32:47.569]                             return(sendCondition)
[15:32:47.569]                           }
[15:32:47.569]                         }
[15:32:47.569]                         frame <- frame + 1L
[15:32:47.569]                         envir <- sys.frame(frame)
[15:32:47.569]                       }
[15:32:47.569]                     }
[15:32:47.569]                     sendCondition <<- function(cond) NULL
[15:32:47.569]                   }
[15:32:47.569]                 })
[15:32:47.569]                 withCallingHandlers({
[15:32:47.569]                   {
[15:32:47.569]                     do.call(function(...) {
[15:32:47.569]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.569]                       if (!identical(...future.globals.maxSize.org, 
[15:32:47.569]                         ...future.globals.maxSize)) {
[15:32:47.569]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.569]                         on.exit(options(oopts), add = TRUE)
[15:32:47.569]                       }
[15:32:47.569]                       {
[15:32:47.569]                         lapply(seq_along(...future.elements_ii), 
[15:32:47.569]                           FUN = function(jj) {
[15:32:47.569]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.569]                             ...future.FUN(...future.X_jj, ...)
[15:32:47.569]                           })
[15:32:47.569]                       }
[15:32:47.569]                     }, args = future.call.arguments)
[15:32:47.569]                   }
[15:32:47.569]                 }, immediateCondition = function(cond) {
[15:32:47.569]                   sendCondition <- ...future.makeSendCondition()
[15:32:47.569]                   sendCondition(cond)
[15:32:47.569]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.569]                   {
[15:32:47.569]                     inherits <- base::inherits
[15:32:47.569]                     invokeRestart <- base::invokeRestart
[15:32:47.569]                     is.null <- base::is.null
[15:32:47.569]                     muffled <- FALSE
[15:32:47.569]                     if (inherits(cond, "message")) {
[15:32:47.569]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:47.569]                       if (muffled) 
[15:32:47.569]                         invokeRestart("muffleMessage")
[15:32:47.569]                     }
[15:32:47.569]                     else if (inherits(cond, "warning")) {
[15:32:47.569]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:47.569]                       if (muffled) 
[15:32:47.569]                         invokeRestart("muffleWarning")
[15:32:47.569]                     }
[15:32:47.569]                     else if (inherits(cond, "condition")) {
[15:32:47.569]                       if (!is.null(pattern)) {
[15:32:47.569]                         computeRestarts <- base::computeRestarts
[15:32:47.569]                         grepl <- base::grepl
[15:32:47.569]                         restarts <- computeRestarts(cond)
[15:32:47.569]                         for (restart in restarts) {
[15:32:47.569]                           name <- restart$name
[15:32:47.569]                           if (is.null(name)) 
[15:32:47.569]                             next
[15:32:47.569]                           if (!grepl(pattern, name)) 
[15:32:47.569]                             next
[15:32:47.569]                           invokeRestart(restart)
[15:32:47.569]                           muffled <- TRUE
[15:32:47.569]                           break
[15:32:47.569]                         }
[15:32:47.569]                       }
[15:32:47.569]                     }
[15:32:47.569]                     invisible(muffled)
[15:32:47.569]                   }
[15:32:47.569]                   muffleCondition(cond)
[15:32:47.569]                 })
[15:32:47.569]             }))
[15:32:47.569]             future::FutureResult(value = ...future.value$value, 
[15:32:47.569]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:47.569]                   ...future.rng), globalenv = if (FALSE) 
[15:32:47.569]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:47.569]                     ...future.globalenv.names))
[15:32:47.569]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:47.569]         }, condition = base::local({
[15:32:47.569]             c <- base::c
[15:32:47.569]             inherits <- base::inherits
[15:32:47.569]             invokeRestart <- base::invokeRestart
[15:32:47.569]             length <- base::length
[15:32:47.569]             list <- base::list
[15:32:47.569]             seq.int <- base::seq.int
[15:32:47.569]             signalCondition <- base::signalCondition
[15:32:47.569]             sys.calls <- base::sys.calls
[15:32:47.569]             `[[` <- base::`[[`
[15:32:47.569]             `+` <- base::`+`
[15:32:47.569]             `<<-` <- base::`<<-`
[15:32:47.569]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:47.569]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:47.569]                   3L)]
[15:32:47.569]             }
[15:32:47.569]             function(cond) {
[15:32:47.569]                 is_error <- inherits(cond, "error")
[15:32:47.569]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:47.569]                   NULL)
[15:32:47.569]                 if (is_error) {
[15:32:47.569]                   sessionInformation <- function() {
[15:32:47.569]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:47.569]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:47.569]                       search = base::search(), system = base::Sys.info())
[15:32:47.569]                   }
[15:32:47.569]                   ...future.conditions[[length(...future.conditions) + 
[15:32:47.569]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:47.569]                     cond$call), session = sessionInformation(), 
[15:32:47.569]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:47.569]                   signalCondition(cond)
[15:32:47.569]                 }
[15:32:47.569]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:47.569]                 "immediateCondition"))) {
[15:32:47.569]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:47.569]                   ...future.conditions[[length(...future.conditions) + 
[15:32:47.569]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:47.569]                   if (TRUE && !signal) {
[15:32:47.569]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.569]                     {
[15:32:47.569]                       inherits <- base::inherits
[15:32:47.569]                       invokeRestart <- base::invokeRestart
[15:32:47.569]                       is.null <- base::is.null
[15:32:47.569]                       muffled <- FALSE
[15:32:47.569]                       if (inherits(cond, "message")) {
[15:32:47.569]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:47.569]                         if (muffled) 
[15:32:47.569]                           invokeRestart("muffleMessage")
[15:32:47.569]                       }
[15:32:47.569]                       else if (inherits(cond, "warning")) {
[15:32:47.569]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:47.569]                         if (muffled) 
[15:32:47.569]                           invokeRestart("muffleWarning")
[15:32:47.569]                       }
[15:32:47.569]                       else if (inherits(cond, "condition")) {
[15:32:47.569]                         if (!is.null(pattern)) {
[15:32:47.569]                           computeRestarts <- base::computeRestarts
[15:32:47.569]                           grepl <- base::grepl
[15:32:47.569]                           restarts <- computeRestarts(cond)
[15:32:47.569]                           for (restart in restarts) {
[15:32:47.569]                             name <- restart$name
[15:32:47.569]                             if (is.null(name)) 
[15:32:47.569]                               next
[15:32:47.569]                             if (!grepl(pattern, name)) 
[15:32:47.569]                               next
[15:32:47.569]                             invokeRestart(restart)
[15:32:47.569]                             muffled <- TRUE
[15:32:47.569]                             break
[15:32:47.569]                           }
[15:32:47.569]                         }
[15:32:47.569]                       }
[15:32:47.569]                       invisible(muffled)
[15:32:47.569]                     }
[15:32:47.569]                     muffleCondition(cond, pattern = "^muffle")
[15:32:47.569]                   }
[15:32:47.569]                 }
[15:32:47.569]                 else {
[15:32:47.569]                   if (TRUE) {
[15:32:47.569]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.569]                     {
[15:32:47.569]                       inherits <- base::inherits
[15:32:47.569]                       invokeRestart <- base::invokeRestart
[15:32:47.569]                       is.null <- base::is.null
[15:32:47.569]                       muffled <- FALSE
[15:32:47.569]                       if (inherits(cond, "message")) {
[15:32:47.569]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:47.569]                         if (muffled) 
[15:32:47.569]                           invokeRestart("muffleMessage")
[15:32:47.569]                       }
[15:32:47.569]                       else if (inherits(cond, "warning")) {
[15:32:47.569]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:47.569]                         if (muffled) 
[15:32:47.569]                           invokeRestart("muffleWarning")
[15:32:47.569]                       }
[15:32:47.569]                       else if (inherits(cond, "condition")) {
[15:32:47.569]                         if (!is.null(pattern)) {
[15:32:47.569]                           computeRestarts <- base::computeRestarts
[15:32:47.569]                           grepl <- base::grepl
[15:32:47.569]                           restarts <- computeRestarts(cond)
[15:32:47.569]                           for (restart in restarts) {
[15:32:47.569]                             name <- restart$name
[15:32:47.569]                             if (is.null(name)) 
[15:32:47.569]                               next
[15:32:47.569]                             if (!grepl(pattern, name)) 
[15:32:47.569]                               next
[15:32:47.569]                             invokeRestart(restart)
[15:32:47.569]                             muffled <- TRUE
[15:32:47.569]                             break
[15:32:47.569]                           }
[15:32:47.569]                         }
[15:32:47.569]                       }
[15:32:47.569]                       invisible(muffled)
[15:32:47.569]                     }
[15:32:47.569]                     muffleCondition(cond, pattern = "^muffle")
[15:32:47.569]                   }
[15:32:47.569]                 }
[15:32:47.569]             }
[15:32:47.569]         }))
[15:32:47.569]     }, error = function(ex) {
[15:32:47.569]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:47.569]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:47.569]                 ...future.rng), started = ...future.startTime, 
[15:32:47.569]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:47.569]             version = "1.8"), class = "FutureResult")
[15:32:47.569]     }, finally = {
[15:32:47.569]         if (!identical(...future.workdir, getwd())) 
[15:32:47.569]             setwd(...future.workdir)
[15:32:47.569]         {
[15:32:47.569]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:47.569]                 ...future.oldOptions$nwarnings <- NULL
[15:32:47.569]             }
[15:32:47.569]             base::options(...future.oldOptions)
[15:32:47.569]             if (.Platform$OS.type == "windows") {
[15:32:47.569]                 old_names <- names(...future.oldEnvVars)
[15:32:47.569]                 envs <- base::Sys.getenv()
[15:32:47.569]                 names <- names(envs)
[15:32:47.569]                 common <- intersect(names, old_names)
[15:32:47.569]                 added <- setdiff(names, old_names)
[15:32:47.569]                 removed <- setdiff(old_names, names)
[15:32:47.569]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:47.569]                   envs[common]]
[15:32:47.569]                 NAMES <- toupper(changed)
[15:32:47.569]                 args <- list()
[15:32:47.569]                 for (kk in seq_along(NAMES)) {
[15:32:47.569]                   name <- changed[[kk]]
[15:32:47.569]                   NAME <- NAMES[[kk]]
[15:32:47.569]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.569]                     next
[15:32:47.569]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:47.569]                 }
[15:32:47.569]                 NAMES <- toupper(added)
[15:32:47.569]                 for (kk in seq_along(NAMES)) {
[15:32:47.569]                   name <- added[[kk]]
[15:32:47.569]                   NAME <- NAMES[[kk]]
[15:32:47.569]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.569]                     next
[15:32:47.569]                   args[[name]] <- ""
[15:32:47.569]                 }
[15:32:47.569]                 NAMES <- toupper(removed)
[15:32:47.569]                 for (kk in seq_along(NAMES)) {
[15:32:47.569]                   name <- removed[[kk]]
[15:32:47.569]                   NAME <- NAMES[[kk]]
[15:32:47.569]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.569]                     next
[15:32:47.569]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:47.569]                 }
[15:32:47.569]                 if (length(args) > 0) 
[15:32:47.569]                   base::do.call(base::Sys.setenv, args = args)
[15:32:47.569]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:47.569]             }
[15:32:47.569]             else {
[15:32:47.569]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:47.569]             }
[15:32:47.569]             {
[15:32:47.569]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:47.569]                   0L) {
[15:32:47.569]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:47.569]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:47.569]                   base::options(opts)
[15:32:47.569]                 }
[15:32:47.569]                 {
[15:32:47.569]                   {
[15:32:47.569]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:47.569]                     NULL
[15:32:47.569]                   }
[15:32:47.569]                   options(future.plan = NULL)
[15:32:47.569]                   if (is.na(NA_character_)) 
[15:32:47.569]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:47.569]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:47.569]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:47.569]                     .init = FALSE)
[15:32:47.569]                 }
[15:32:47.569]             }
[15:32:47.569]         }
[15:32:47.569]     })
[15:32:47.569]     if (TRUE) {
[15:32:47.569]         base::sink(type = "output", split = FALSE)
[15:32:47.569]         if (TRUE) {
[15:32:47.569]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:47.569]         }
[15:32:47.569]         else {
[15:32:47.569]             ...future.result["stdout"] <- base::list(NULL)
[15:32:47.569]         }
[15:32:47.569]         base::close(...future.stdout)
[15:32:47.569]         ...future.stdout <- NULL
[15:32:47.569]     }
[15:32:47.569]     ...future.result$conditions <- ...future.conditions
[15:32:47.569]     ...future.result$finished <- base::Sys.time()
[15:32:47.569]     ...future.result
[15:32:47.569] }
[15:32:47.578] Exporting 11 global objects (93.23 KiB) to cluster node #1 ...
[15:32:47.578] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:47.579] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:47.579] Exporting 'x_FUN' (1.16 KiB) to cluster node #1 ...
[15:32:47.580] Exporting 'x_FUN' (1.16 KiB) to cluster node #1 ... DONE
[15:32:47.580] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:47.580] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:47.581] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:47.581] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:47.582] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:47.582] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:47.583] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:47.583] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:47.584] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:47.584] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:47.585] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:47.585] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:47.585] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:47.586] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:47.586] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:47.587] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:47.587] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:47.588] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:47.588] Exporting 11 global objects (93.23 KiB) to cluster node #1 ... DONE
[15:32:47.589] MultisessionFuture started
[15:32:47.589] - Launch lazy future ... done
[15:32:47.589] run() for 'MultisessionFuture' ... done
[15:32:47.590] Created future:
[15:32:47.613] receiveMessageFromWorker() for ClusterFuture ...
[15:32:47.614] - Validating connection of MultisessionFuture
[15:32:47.614] - received message: FutureResult
[15:32:47.614] - Received FutureResult
[15:32:47.614] - Erased future from FutureRegistry
[15:32:47.615] result() for ClusterFuture ...
[15:32:47.615] - result already collected: FutureResult
[15:32:47.615] result() for ClusterFuture ... done
[15:32:47.615] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:47.590] MultisessionFuture:
[15:32:47.590] Label: 'future_vapply-1'
[15:32:47.590] Expression:
[15:32:47.590] {
[15:32:47.590]     do.call(function(...) {
[15:32:47.590]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.590]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.590]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.590]             on.exit(options(oopts), add = TRUE)
[15:32:47.590]         }
[15:32:47.590]         {
[15:32:47.590]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.590]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.590]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.590]             })
[15:32:47.590]         }
[15:32:47.590]     }, args = future.call.arguments)
[15:32:47.590] }
[15:32:47.590] Lazy evaluation: FALSE
[15:32:47.590] Asynchronous evaluation: TRUE
[15:32:47.590] Local evaluation: TRUE
[15:32:47.590] Environment: R_GlobalEnv
[15:32:47.590] Capture standard output: TRUE
[15:32:47.590] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:47.590] Globals: 11 objects totaling 93.51 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 1.16 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:47.590] Packages: 1 packages ('future.apply')
[15:32:47.590] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:47.590] Resolved: TRUE
[15:32:47.590] Value: <not collected>
[15:32:47.590] Conditions captured: <none>
[15:32:47.590] Early signaling: FALSE
[15:32:47.590] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:47.590] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:47.616] Chunk #1 of 2 ... DONE
[15:32:47.616] Chunk #2 of 2 ...
[15:32:47.616]  - Finding globals in 'X' for chunk #2 ...
[15:32:47.617] getGlobalsAndPackages() ...
[15:32:47.617] Searching for globals...
[15:32:47.617] 
[15:32:47.617] Searching for globals ... DONE
[15:32:47.618] - globals: [0] <none>
[15:32:47.618] getGlobalsAndPackages() ... DONE
[15:32:47.618]    + additional globals found: [n=0] 
[15:32:47.618]    + additional namespaces needed: [n=0] 
[15:32:47.618]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:47.619]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:47.619]  - seeds: <none>
[15:32:47.619]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.619] getGlobalsAndPackages() ...
[15:32:47.619] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.620] Resolving globals: FALSE
[15:32:47.620] Tweak future expression to call with '...' arguments ...
[15:32:47.620] {
[15:32:47.620]     do.call(function(...) {
[15:32:47.620]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.620]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.620]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.620]             on.exit(options(oopts), add = TRUE)
[15:32:47.620]         }
[15:32:47.620]         {
[15:32:47.620]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.620]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.620]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.620]             })
[15:32:47.620]         }
[15:32:47.620]     }, args = future.call.arguments)
[15:32:47.620] }
[15:32:47.621] Tweak future expression to call with '...' arguments ... DONE
[15:32:47.622] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.622] - packages: [1] 'future.apply'
[15:32:47.622] getGlobalsAndPackages() ... DONE
[15:32:47.623] run() for 'Future' ...
[15:32:47.623] - state: 'created'
[15:32:47.623] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:47.638] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:47.639] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:47.639]   - Field: 'node'
[15:32:47.639]   - Field: 'label'
[15:32:47.639]   - Field: 'local'
[15:32:47.639]   - Field: 'owner'
[15:32:47.640]   - Field: 'envir'
[15:32:47.640]   - Field: 'workers'
[15:32:47.640]   - Field: 'packages'
[15:32:47.640]   - Field: 'gc'
[15:32:47.641]   - Field: 'conditions'
[15:32:47.641]   - Field: 'persistent'
[15:32:47.641]   - Field: 'expr'
[15:32:47.641]   - Field: 'uuid'
[15:32:47.642]   - Field: 'seed'
[15:32:47.642]   - Field: 'version'
[15:32:47.642]   - Field: 'result'
[15:32:47.642]   - Field: 'asynchronous'
[15:32:47.643]   - Field: 'calls'
[15:32:47.643]   - Field: 'globals'
[15:32:47.643]   - Field: 'stdout'
[15:32:47.643]   - Field: 'earlySignal'
[15:32:47.643]   - Field: 'lazy'
[15:32:47.644]   - Field: 'state'
[15:32:47.644] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:47.644] - Launch lazy future ...
[15:32:47.645] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:47.645] Packages needed by future strategies (n = 0): <none>
[15:32:47.646] {
[15:32:47.646]     {
[15:32:47.646]         {
[15:32:47.646]             ...future.startTime <- base::Sys.time()
[15:32:47.646]             {
[15:32:47.646]                 {
[15:32:47.646]                   {
[15:32:47.646]                     {
[15:32:47.646]                       {
[15:32:47.646]                         base::local({
[15:32:47.646]                           has_future <- base::requireNamespace("future", 
[15:32:47.646]                             quietly = TRUE)
[15:32:47.646]                           if (has_future) {
[15:32:47.646]                             ns <- base::getNamespace("future")
[15:32:47.646]                             version <- ns[[".package"]][["version"]]
[15:32:47.646]                             if (is.null(version)) 
[15:32:47.646]                               version <- utils::packageVersion("future")
[15:32:47.646]                           }
[15:32:47.646]                           else {
[15:32:47.646]                             version <- NULL
[15:32:47.646]                           }
[15:32:47.646]                           if (!has_future || version < "1.8.0") {
[15:32:47.646]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:47.646]                               "", base::R.version$version.string), 
[15:32:47.646]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:47.646]                                 base::R.version$platform, 8 * 
[15:32:47.646]                                   base::.Machine$sizeof.pointer), 
[15:32:47.646]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:47.646]                                 "release", "version")], collapse = " "), 
[15:32:47.646]                               hostname = base::Sys.info()[["nodename"]])
[15:32:47.646]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:47.646]                               info)
[15:32:47.646]                             info <- base::paste(info, collapse = "; ")
[15:32:47.646]                             if (!has_future) {
[15:32:47.646]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:47.646]                                 info)
[15:32:47.646]                             }
[15:32:47.646]                             else {
[15:32:47.646]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:47.646]                                 info, version)
[15:32:47.646]                             }
[15:32:47.646]                             base::stop(msg)
[15:32:47.646]                           }
[15:32:47.646]                         })
[15:32:47.646]                       }
[15:32:47.646]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:47.646]                       base::options(mc.cores = 1L)
[15:32:47.646]                     }
[15:32:47.646]                     base::local({
[15:32:47.646]                       for (pkg in "future.apply") {
[15:32:47.646]                         base::loadNamespace(pkg)
[15:32:47.646]                         base::library(pkg, character.only = TRUE)
[15:32:47.646]                       }
[15:32:47.646]                     })
[15:32:47.646]                   }
[15:32:47.646]                   ...future.strategy.old <- future::plan("list")
[15:32:47.646]                   options(future.plan = NULL)
[15:32:47.646]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:47.646]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:47.646]                 }
[15:32:47.646]                 ...future.workdir <- getwd()
[15:32:47.646]             }
[15:32:47.646]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:47.646]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:47.646]         }
[15:32:47.646]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:47.646]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:47.646]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:47.646]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:47.646]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:47.646]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:47.646]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:47.646]             base::names(...future.oldOptions))
[15:32:47.646]     }
[15:32:47.646]     if (FALSE) {
[15:32:47.646]     }
[15:32:47.646]     else {
[15:32:47.646]         if (TRUE) {
[15:32:47.646]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:47.646]                 open = "w")
[15:32:47.646]         }
[15:32:47.646]         else {
[15:32:47.646]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:47.646]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:47.646]         }
[15:32:47.646]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:47.646]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:47.646]             base::sink(type = "output", split = FALSE)
[15:32:47.646]             base::close(...future.stdout)
[15:32:47.646]         }, add = TRUE)
[15:32:47.646]     }
[15:32:47.646]     ...future.frame <- base::sys.nframe()
[15:32:47.646]     ...future.conditions <- base::list()
[15:32:47.646]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:47.646]     if (FALSE) {
[15:32:47.646]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:47.646]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:47.646]     }
[15:32:47.646]     ...future.result <- base::tryCatch({
[15:32:47.646]         base::withCallingHandlers({
[15:32:47.646]             ...future.value <- base::withVisible(base::local({
[15:32:47.646]                 ...future.makeSendCondition <- base::local({
[15:32:47.646]                   sendCondition <- NULL
[15:32:47.646]                   function(frame = 1L) {
[15:32:47.646]                     if (is.function(sendCondition)) 
[15:32:47.646]                       return(sendCondition)
[15:32:47.646]                     ns <- getNamespace("parallel")
[15:32:47.646]                     if (exists("sendData", mode = "function", 
[15:32:47.646]                       envir = ns)) {
[15:32:47.646]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:47.646]                         envir = ns)
[15:32:47.646]                       envir <- sys.frame(frame)
[15:32:47.646]                       master <- NULL
[15:32:47.646]                       while (!identical(envir, .GlobalEnv) && 
[15:32:47.646]                         !identical(envir, emptyenv())) {
[15:32:47.646]                         if (exists("master", mode = "list", envir = envir, 
[15:32:47.646]                           inherits = FALSE)) {
[15:32:47.646]                           master <- get("master", mode = "list", 
[15:32:47.646]                             envir = envir, inherits = FALSE)
[15:32:47.646]                           if (inherits(master, c("SOCKnode", 
[15:32:47.646]                             "SOCK0node"))) {
[15:32:47.646]                             sendCondition <<- function(cond) {
[15:32:47.646]                               data <- list(type = "VALUE", value = cond, 
[15:32:47.646]                                 success = TRUE)
[15:32:47.646]                               parallel_sendData(master, data)
[15:32:47.646]                             }
[15:32:47.646]                             return(sendCondition)
[15:32:47.646]                           }
[15:32:47.646]                         }
[15:32:47.646]                         frame <- frame + 1L
[15:32:47.646]                         envir <- sys.frame(frame)
[15:32:47.646]                       }
[15:32:47.646]                     }
[15:32:47.646]                     sendCondition <<- function(cond) NULL
[15:32:47.646]                   }
[15:32:47.646]                 })
[15:32:47.646]                 withCallingHandlers({
[15:32:47.646]                   {
[15:32:47.646]                     do.call(function(...) {
[15:32:47.646]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.646]                       if (!identical(...future.globals.maxSize.org, 
[15:32:47.646]                         ...future.globals.maxSize)) {
[15:32:47.646]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.646]                         on.exit(options(oopts), add = TRUE)
[15:32:47.646]                       }
[15:32:47.646]                       {
[15:32:47.646]                         lapply(seq_along(...future.elements_ii), 
[15:32:47.646]                           FUN = function(jj) {
[15:32:47.646]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.646]                             ...future.FUN(...future.X_jj, ...)
[15:32:47.646]                           })
[15:32:47.646]                       }
[15:32:47.646]                     }, args = future.call.arguments)
[15:32:47.646]                   }
[15:32:47.646]                 }, immediateCondition = function(cond) {
[15:32:47.646]                   sendCondition <- ...future.makeSendCondition()
[15:32:47.646]                   sendCondition(cond)
[15:32:47.646]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.646]                   {
[15:32:47.646]                     inherits <- base::inherits
[15:32:47.646]                     invokeRestart <- base::invokeRestart
[15:32:47.646]                     is.null <- base::is.null
[15:32:47.646]                     muffled <- FALSE
[15:32:47.646]                     if (inherits(cond, "message")) {
[15:32:47.646]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:47.646]                       if (muffled) 
[15:32:47.646]                         invokeRestart("muffleMessage")
[15:32:47.646]                     }
[15:32:47.646]                     else if (inherits(cond, "warning")) {
[15:32:47.646]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:47.646]                       if (muffled) 
[15:32:47.646]                         invokeRestart("muffleWarning")
[15:32:47.646]                     }
[15:32:47.646]                     else if (inherits(cond, "condition")) {
[15:32:47.646]                       if (!is.null(pattern)) {
[15:32:47.646]                         computeRestarts <- base::computeRestarts
[15:32:47.646]                         grepl <- base::grepl
[15:32:47.646]                         restarts <- computeRestarts(cond)
[15:32:47.646]                         for (restart in restarts) {
[15:32:47.646]                           name <- restart$name
[15:32:47.646]                           if (is.null(name)) 
[15:32:47.646]                             next
[15:32:47.646]                           if (!grepl(pattern, name)) 
[15:32:47.646]                             next
[15:32:47.646]                           invokeRestart(restart)
[15:32:47.646]                           muffled <- TRUE
[15:32:47.646]                           break
[15:32:47.646]                         }
[15:32:47.646]                       }
[15:32:47.646]                     }
[15:32:47.646]                     invisible(muffled)
[15:32:47.646]                   }
[15:32:47.646]                   muffleCondition(cond)
[15:32:47.646]                 })
[15:32:47.646]             }))
[15:32:47.646]             future::FutureResult(value = ...future.value$value, 
[15:32:47.646]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:47.646]                   ...future.rng), globalenv = if (FALSE) 
[15:32:47.646]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:47.646]                     ...future.globalenv.names))
[15:32:47.646]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:47.646]         }, condition = base::local({
[15:32:47.646]             c <- base::c
[15:32:47.646]             inherits <- base::inherits
[15:32:47.646]             invokeRestart <- base::invokeRestart
[15:32:47.646]             length <- base::length
[15:32:47.646]             list <- base::list
[15:32:47.646]             seq.int <- base::seq.int
[15:32:47.646]             signalCondition <- base::signalCondition
[15:32:47.646]             sys.calls <- base::sys.calls
[15:32:47.646]             `[[` <- base::`[[`
[15:32:47.646]             `+` <- base::`+`
[15:32:47.646]             `<<-` <- base::`<<-`
[15:32:47.646]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:47.646]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:47.646]                   3L)]
[15:32:47.646]             }
[15:32:47.646]             function(cond) {
[15:32:47.646]                 is_error <- inherits(cond, "error")
[15:32:47.646]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:47.646]                   NULL)
[15:32:47.646]                 if (is_error) {
[15:32:47.646]                   sessionInformation <- function() {
[15:32:47.646]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:47.646]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:47.646]                       search = base::search(), system = base::Sys.info())
[15:32:47.646]                   }
[15:32:47.646]                   ...future.conditions[[length(...future.conditions) + 
[15:32:47.646]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:47.646]                     cond$call), session = sessionInformation(), 
[15:32:47.646]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:47.646]                   signalCondition(cond)
[15:32:47.646]                 }
[15:32:47.646]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:47.646]                 "immediateCondition"))) {
[15:32:47.646]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:47.646]                   ...future.conditions[[length(...future.conditions) + 
[15:32:47.646]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:47.646]                   if (TRUE && !signal) {
[15:32:47.646]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.646]                     {
[15:32:47.646]                       inherits <- base::inherits
[15:32:47.646]                       invokeRestart <- base::invokeRestart
[15:32:47.646]                       is.null <- base::is.null
[15:32:47.646]                       muffled <- FALSE
[15:32:47.646]                       if (inherits(cond, "message")) {
[15:32:47.646]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:47.646]                         if (muffled) 
[15:32:47.646]                           invokeRestart("muffleMessage")
[15:32:47.646]                       }
[15:32:47.646]                       else if (inherits(cond, "warning")) {
[15:32:47.646]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:47.646]                         if (muffled) 
[15:32:47.646]                           invokeRestart("muffleWarning")
[15:32:47.646]                       }
[15:32:47.646]                       else if (inherits(cond, "condition")) {
[15:32:47.646]                         if (!is.null(pattern)) {
[15:32:47.646]                           computeRestarts <- base::computeRestarts
[15:32:47.646]                           grepl <- base::grepl
[15:32:47.646]                           restarts <- computeRestarts(cond)
[15:32:47.646]                           for (restart in restarts) {
[15:32:47.646]                             name <- restart$name
[15:32:47.646]                             if (is.null(name)) 
[15:32:47.646]                               next
[15:32:47.646]                             if (!grepl(pattern, name)) 
[15:32:47.646]                               next
[15:32:47.646]                             invokeRestart(restart)
[15:32:47.646]                             muffled <- TRUE
[15:32:47.646]                             break
[15:32:47.646]                           }
[15:32:47.646]                         }
[15:32:47.646]                       }
[15:32:47.646]                       invisible(muffled)
[15:32:47.646]                     }
[15:32:47.646]                     muffleCondition(cond, pattern = "^muffle")
[15:32:47.646]                   }
[15:32:47.646]                 }
[15:32:47.646]                 else {
[15:32:47.646]                   if (TRUE) {
[15:32:47.646]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.646]                     {
[15:32:47.646]                       inherits <- base::inherits
[15:32:47.646]                       invokeRestart <- base::invokeRestart
[15:32:47.646]                       is.null <- base::is.null
[15:32:47.646]                       muffled <- FALSE
[15:32:47.646]                       if (inherits(cond, "message")) {
[15:32:47.646]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:47.646]                         if (muffled) 
[15:32:47.646]                           invokeRestart("muffleMessage")
[15:32:47.646]                       }
[15:32:47.646]                       else if (inherits(cond, "warning")) {
[15:32:47.646]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:47.646]                         if (muffled) 
[15:32:47.646]                           invokeRestart("muffleWarning")
[15:32:47.646]                       }
[15:32:47.646]                       else if (inherits(cond, "condition")) {
[15:32:47.646]                         if (!is.null(pattern)) {
[15:32:47.646]                           computeRestarts <- base::computeRestarts
[15:32:47.646]                           grepl <- base::grepl
[15:32:47.646]                           restarts <- computeRestarts(cond)
[15:32:47.646]                           for (restart in restarts) {
[15:32:47.646]                             name <- restart$name
[15:32:47.646]                             if (is.null(name)) 
[15:32:47.646]                               next
[15:32:47.646]                             if (!grepl(pattern, name)) 
[15:32:47.646]                               next
[15:32:47.646]                             invokeRestart(restart)
[15:32:47.646]                             muffled <- TRUE
[15:32:47.646]                             break
[15:32:47.646]                           }
[15:32:47.646]                         }
[15:32:47.646]                       }
[15:32:47.646]                       invisible(muffled)
[15:32:47.646]                     }
[15:32:47.646]                     muffleCondition(cond, pattern = "^muffle")
[15:32:47.646]                   }
[15:32:47.646]                 }
[15:32:47.646]             }
[15:32:47.646]         }))
[15:32:47.646]     }, error = function(ex) {
[15:32:47.646]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:47.646]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:47.646]                 ...future.rng), started = ...future.startTime, 
[15:32:47.646]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:47.646]             version = "1.8"), class = "FutureResult")
[15:32:47.646]     }, finally = {
[15:32:47.646]         if (!identical(...future.workdir, getwd())) 
[15:32:47.646]             setwd(...future.workdir)
[15:32:47.646]         {
[15:32:47.646]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:47.646]                 ...future.oldOptions$nwarnings <- NULL
[15:32:47.646]             }
[15:32:47.646]             base::options(...future.oldOptions)
[15:32:47.646]             if (.Platform$OS.type == "windows") {
[15:32:47.646]                 old_names <- names(...future.oldEnvVars)
[15:32:47.646]                 envs <- base::Sys.getenv()
[15:32:47.646]                 names <- names(envs)
[15:32:47.646]                 common <- intersect(names, old_names)
[15:32:47.646]                 added <- setdiff(names, old_names)
[15:32:47.646]                 removed <- setdiff(old_names, names)
[15:32:47.646]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:47.646]                   envs[common]]
[15:32:47.646]                 NAMES <- toupper(changed)
[15:32:47.646]                 args <- list()
[15:32:47.646]                 for (kk in seq_along(NAMES)) {
[15:32:47.646]                   name <- changed[[kk]]
[15:32:47.646]                   NAME <- NAMES[[kk]]
[15:32:47.646]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.646]                     next
[15:32:47.646]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:47.646]                 }
[15:32:47.646]                 NAMES <- toupper(added)
[15:32:47.646]                 for (kk in seq_along(NAMES)) {
[15:32:47.646]                   name <- added[[kk]]
[15:32:47.646]                   NAME <- NAMES[[kk]]
[15:32:47.646]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.646]                     next
[15:32:47.646]                   args[[name]] <- ""
[15:32:47.646]                 }
[15:32:47.646]                 NAMES <- toupper(removed)
[15:32:47.646]                 for (kk in seq_along(NAMES)) {
[15:32:47.646]                   name <- removed[[kk]]
[15:32:47.646]                   NAME <- NAMES[[kk]]
[15:32:47.646]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.646]                     next
[15:32:47.646]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:47.646]                 }
[15:32:47.646]                 if (length(args) > 0) 
[15:32:47.646]                   base::do.call(base::Sys.setenv, args = args)
[15:32:47.646]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:47.646]             }
[15:32:47.646]             else {
[15:32:47.646]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:47.646]             }
[15:32:47.646]             {
[15:32:47.646]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:47.646]                   0L) {
[15:32:47.646]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:47.646]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:47.646]                   base::options(opts)
[15:32:47.646]                 }
[15:32:47.646]                 {
[15:32:47.646]                   {
[15:32:47.646]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:47.646]                     NULL
[15:32:47.646]                   }
[15:32:47.646]                   options(future.plan = NULL)
[15:32:47.646]                   if (is.na(NA_character_)) 
[15:32:47.646]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:47.646]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:47.646]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:47.646]                     .init = FALSE)
[15:32:47.646]                 }
[15:32:47.646]             }
[15:32:47.646]         }
[15:32:47.646]     })
[15:32:47.646]     if (TRUE) {
[15:32:47.646]         base::sink(type = "output", split = FALSE)
[15:32:47.646]         if (TRUE) {
[15:32:47.646]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:47.646]         }
[15:32:47.646]         else {
[15:32:47.646]             ...future.result["stdout"] <- base::list(NULL)
[15:32:47.646]         }
[15:32:47.646]         base::close(...future.stdout)
[15:32:47.646]         ...future.stdout <- NULL
[15:32:47.646]     }
[15:32:47.646]     ...future.result$conditions <- ...future.conditions
[15:32:47.646]     ...future.result$finished <- base::Sys.time()
[15:32:47.646]     ...future.result
[15:32:47.646] }
[15:32:47.653] Exporting 11 global objects (93.23 KiB) to cluster node #1 ...
[15:32:47.653] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:47.654] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:47.655] Exporting 'x_FUN' (1.16 KiB) to cluster node #1 ...
[15:32:47.655] Exporting 'x_FUN' (1.16 KiB) to cluster node #1 ... DONE
[15:32:47.656] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:47.656] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:47.657] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:47.658] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:47.658] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:47.659] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:47.659] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:47.660] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:47.661] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:47.661] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:47.662] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:47.662] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:47.663] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:47.663] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:47.664] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:47.666] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:47.667] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:47.667] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:47.668] Exporting 11 global objects (93.23 KiB) to cluster node #1 ... DONE
[15:32:47.672] MultisessionFuture started
[15:32:47.672] - Launch lazy future ... done
[15:32:47.672] run() for 'MultisessionFuture' ... done
[15:32:47.672] Created future:
[15:32:47.698] receiveMessageFromWorker() for ClusterFuture ...
[15:32:47.698] - Validating connection of MultisessionFuture
[15:32:47.698] - received message: FutureResult
[15:32:47.699] - Received FutureResult
[15:32:47.699] - Erased future from FutureRegistry
[15:32:47.699] result() for ClusterFuture ...
[15:32:47.699] - result already collected: FutureResult
[15:32:47.700] result() for ClusterFuture ... done
[15:32:47.700] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:47.673] MultisessionFuture:
[15:32:47.673] Label: 'future_vapply-2'
[15:32:47.673] Expression:
[15:32:47.673] {
[15:32:47.673]     do.call(function(...) {
[15:32:47.673]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.673]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.673]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.673]             on.exit(options(oopts), add = TRUE)
[15:32:47.673]         }
[15:32:47.673]         {
[15:32:47.673]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.673]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.673]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.673]             })
[15:32:47.673]         }
[15:32:47.673]     }, args = future.call.arguments)
[15:32:47.673] }
[15:32:47.673] Lazy evaluation: FALSE
[15:32:47.673] Asynchronous evaluation: TRUE
[15:32:47.673] Local evaluation: TRUE
[15:32:47.673] Environment: R_GlobalEnv
[15:32:47.673] Capture standard output: TRUE
[15:32:47.673] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:47.673] Globals: 11 objects totaling 93.51 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 1.16 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:47.673] Packages: 1 packages ('future.apply')
[15:32:47.673] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:47.673] Resolved: TRUE
[15:32:47.673] Value: <not collected>
[15:32:47.673] Conditions captured: <none>
[15:32:47.673] Early signaling: FALSE
[15:32:47.673] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:47.673] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:47.701] Chunk #2 of 2 ... DONE
[15:32:47.701] Launching 2 futures (chunks) ... DONE
[15:32:47.701] Resolving 2 futures (chunks) ...
[15:32:47.701] resolve() on list ...
[15:32:47.701]  recursive: 0
[15:32:47.702]  length: 2
[15:32:47.702] 
[15:32:47.702] Future #1
[15:32:47.702] result() for ClusterFuture ...
[15:32:47.703] - result already collected: FutureResult
[15:32:47.703] result() for ClusterFuture ... done
[15:32:47.703] result() for ClusterFuture ...
[15:32:47.703] - result already collected: FutureResult
[15:32:47.703] result() for ClusterFuture ... done
[15:32:47.704] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:47.704] - nx: 2
[15:32:47.704] - relay: TRUE
[15:32:47.704] - stdout: TRUE
[15:32:47.705] - signal: TRUE
[15:32:47.705] - resignal: FALSE
[15:32:47.705] - force: TRUE
[15:32:47.705] - relayed: [n=2] FALSE, FALSE
[15:32:47.705] - queued futures: [n=2] FALSE, FALSE
[15:32:47.706]  - until=1
[15:32:47.706]  - relaying element #1
[15:32:47.706] result() for ClusterFuture ...
[15:32:47.706] - result already collected: FutureResult
[15:32:47.706] result() for ClusterFuture ... done
[15:32:47.707] result() for ClusterFuture ...
[15:32:47.707] - result already collected: FutureResult
[15:32:47.707] result() for ClusterFuture ... done
[15:32:47.707] result() for ClusterFuture ...
[15:32:47.708] - result already collected: FutureResult
[15:32:47.708] result() for ClusterFuture ... done
[15:32:47.708] result() for ClusterFuture ...
[15:32:47.708] - result already collected: FutureResult
[15:32:47.709] result() for ClusterFuture ... done
[15:32:47.709] - relayed: [n=2] TRUE, FALSE
[15:32:47.709] - queued futures: [n=2] TRUE, FALSE
[15:32:47.709] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:47.709]  length: 1 (resolved future 1)
[15:32:47.710] Future #2
[15:32:47.710] result() for ClusterFuture ...
[15:32:47.710] - result already collected: FutureResult
[15:32:47.710] result() for ClusterFuture ... done
[15:32:47.711] result() for ClusterFuture ...
[15:32:47.711] - result already collected: FutureResult
[15:32:47.711] result() for ClusterFuture ... done
[15:32:47.711] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:47.711] - nx: 2
[15:32:47.712] - relay: TRUE
[15:32:47.712] - stdout: TRUE
[15:32:47.712] - signal: TRUE
[15:32:47.712] - resignal: FALSE
[15:32:47.713] - force: TRUE
[15:32:47.713] - relayed: [n=2] TRUE, FALSE
[15:32:47.713] - queued futures: [n=2] TRUE, FALSE
[15:32:47.713]  - until=2
[15:32:47.713]  - relaying element #2
[15:32:47.714] result() for ClusterFuture ...
[15:32:47.714] - result already collected: FutureResult
[15:32:47.714] result() for ClusterFuture ... done
[15:32:47.714] result() for ClusterFuture ...
[15:32:47.714] - result already collected: FutureResult
[15:32:47.715] result() for ClusterFuture ... done
[15:32:47.715] result() for ClusterFuture ...
[15:32:47.715] - result already collected: FutureResult
[15:32:47.715] result() for ClusterFuture ... done
[15:32:47.716] result() for ClusterFuture ...
[15:32:47.716] - result already collected: FutureResult
[15:32:47.716] result() for ClusterFuture ... done
[15:32:47.716] - relayed: [n=2] TRUE, TRUE
[15:32:47.716] - queued futures: [n=2] TRUE, TRUE
[15:32:47.717] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:47.717]  length: 0 (resolved future 2)
[15:32:47.717] Relaying remaining futures
[15:32:47.717] signalConditionsASAP(NULL, pos=0) ...
[15:32:47.718] - nx: 2
[15:32:47.718] - relay: TRUE
[15:32:47.718] - stdout: TRUE
[15:32:47.718] - signal: TRUE
[15:32:47.718] - resignal: FALSE
[15:32:47.719] - force: TRUE
[15:32:47.719] - relayed: [n=2] TRUE, TRUE
[15:32:47.719] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:47.719] - relayed: [n=2] TRUE, TRUE
[15:32:47.720] - queued futures: [n=2] TRUE, TRUE
[15:32:47.720] signalConditionsASAP(NULL, pos=0) ... done
[15:32:47.720] resolve() on list ... DONE
[15:32:47.720] result() for ClusterFuture ...
[15:32:47.720] - result already collected: FutureResult
[15:32:47.721] result() for ClusterFuture ... done
[15:32:47.721] result() for ClusterFuture ...
[15:32:47.721] - result already collected: FutureResult
[15:32:47.721] result() for ClusterFuture ... done
[15:32:47.722] result() for ClusterFuture ...
[15:32:47.722] - result already collected: FutureResult
[15:32:47.722] result() for ClusterFuture ... done
[15:32:47.722] result() for ClusterFuture ...
[15:32:47.722] - result already collected: FutureResult
[15:32:47.723] result() for ClusterFuture ... done
[15:32:47.723]  - Number of value chunks collected: 2
[15:32:47.723] Resolving 2 futures (chunks) ... DONE
[15:32:47.723] Reducing values from 2 chunks ...
[15:32:47.724]  - Number of values collected after concatenation: 10
[15:32:47.724]  - Number of values expected: 10
[15:32:47.724] Reducing values from 2 chunks ... DONE
[15:32:47.724] future_lapply() ... DONE
 num[0 , 1:10] 
 int[0 , 1:10] 
[15:32:47.726] future_lapply() ...
[15:32:47.732] Number of chunks: 2
[15:32:47.732] getGlobalsAndPackagesXApply() ...
[15:32:47.733]  - future.globals: TRUE
[15:32:47.733] getGlobalsAndPackages() ...
[15:32:47.733] Searching for globals...
[15:32:47.739] - globals found: [17] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'integer'
[15:32:47.740] Searching for globals ... DONE
[15:32:47.740] Resolving globals: FALSE
[15:32:47.742] The total size of the 7 globals is 93.16 KiB (95400 bytes)
[15:32:47.742] The total size of the 7 globals exported for future expression ('FUN()') is 93.16 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:47.743] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:47.743] - packages: [1] 'future.apply'
[15:32:47.743] getGlobalsAndPackages() ... DONE
[15:32:47.743]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:47.744]  - needed namespaces: [n=1] 'future.apply'
[15:32:47.744] Finding globals ... DONE
[15:32:47.744]  - use_args: TRUE
[15:32:47.744]  - Getting '...' globals ...
[15:32:47.745] resolve() on list ...
[15:32:47.745]  recursive: 0
[15:32:47.745]  length: 1
[15:32:47.745]  elements: '...'
[15:32:47.746]  length: 0 (resolved future 1)
[15:32:47.746] resolve() on list ... DONE
[15:32:47.746]    - '...' content: [n=0] 
[15:32:47.746] List of 1
[15:32:47.746]  $ ...: list()
[15:32:47.746]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:47.746]  - attr(*, "where")=List of 1
[15:32:47.746]   ..$ ...:<environment: 0x0000022d3d26dea0> 
[15:32:47.746]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:47.746]  - attr(*, "resolved")= logi TRUE
[15:32:47.746]  - attr(*, "total_size")= num NA
[15:32:47.751]  - Getting '...' globals ... DONE
[15:32:47.751] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:47.751] List of 8
[15:32:47.751]  $ ...future.FUN:function (x, ...)  
[15:32:47.751]  $ x_FUN        :function (x)  
[15:32:47.751]  $ times        : int 0
[15:32:47.751]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:47.751]  $ stop_if_not  :function (...)  
[15:32:47.751]  $ dim          : NULL
[15:32:47.751]  $ valid_types  : chr [1:2] "logical" "integer"
[15:32:47.751]  $ ...          : list()
[15:32:47.751]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:47.751]  - attr(*, "where")=List of 8
[15:32:47.751]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:47.751]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:47.751]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:47.751]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:47.751]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:47.751]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:47.751]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:47.751]   ..$ ...          :<environment: 0x0000022d3d26dea0> 
[15:32:47.751]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:47.751]  - attr(*, "resolved")= logi FALSE
[15:32:47.751]  - attr(*, "total_size")= num 95400
[15:32:47.761] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:47.761] getGlobalsAndPackagesXApply() ... DONE
[15:32:47.762] Number of futures (= number of chunks): 2
[15:32:47.762] Launching 2 futures (chunks) ...
[15:32:47.762] Chunk #1 of 2 ...
[15:32:47.763]  - Finding globals in 'X' for chunk #1 ...
[15:32:47.763] getGlobalsAndPackages() ...
[15:32:47.763] Searching for globals...
[15:32:47.764] 
[15:32:47.764] Searching for globals ... DONE
[15:32:47.764] - globals: [0] <none>
[15:32:47.765] getGlobalsAndPackages() ... DONE
[15:32:47.765]    + additional globals found: [n=0] 
[15:32:47.765]    + additional namespaces needed: [n=0] 
[15:32:47.765]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:47.766]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:47.766]  - seeds: <none>
[15:32:47.766]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.767] getGlobalsAndPackages() ...
[15:32:47.767] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.767] Resolving globals: FALSE
[15:32:47.767] Tweak future expression to call with '...' arguments ...
[15:32:47.768] {
[15:32:47.768]     do.call(function(...) {
[15:32:47.768]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.768]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.768]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.768]             on.exit(options(oopts), add = TRUE)
[15:32:47.768]         }
[15:32:47.768]         {
[15:32:47.768]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.768]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.768]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.768]             })
[15:32:47.768]         }
[15:32:47.768]     }, args = future.call.arguments)
[15:32:47.768] }
[15:32:47.768] Tweak future expression to call with '...' arguments ... DONE
[15:32:47.770] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.770] - packages: [1] 'future.apply'
[15:32:47.770] getGlobalsAndPackages() ... DONE
[15:32:47.771] run() for 'Future' ...
[15:32:47.771] - state: 'created'
[15:32:47.771] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:47.790] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:47.790] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:47.791]   - Field: 'node'
[15:32:47.791]   - Field: 'label'
[15:32:47.791]   - Field: 'local'
[15:32:47.792]   - Field: 'owner'
[15:32:47.792]   - Field: 'envir'
[15:32:47.792]   - Field: 'workers'
[15:32:47.793]   - Field: 'packages'
[15:32:47.793]   - Field: 'gc'
[15:32:47.793]   - Field: 'conditions'
[15:32:47.793]   - Field: 'persistent'
[15:32:47.794]   - Field: 'expr'
[15:32:47.794]   - Field: 'uuid'
[15:32:47.794]   - Field: 'seed'
[15:32:47.795]   - Field: 'version'
[15:32:47.795]   - Field: 'result'
[15:32:47.795]   - Field: 'asynchronous'
[15:32:47.796]   - Field: 'calls'
[15:32:47.796]   - Field: 'globals'
[15:32:47.796]   - Field: 'stdout'
[15:32:47.797]   - Field: 'earlySignal'
[15:32:47.797]   - Field: 'lazy'
[15:32:47.797]   - Field: 'state'
[15:32:47.797] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:47.798] - Launch lazy future ...
[15:32:47.798] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:47.799] Packages needed by future strategies (n = 0): <none>
[15:32:47.800] {
[15:32:47.800]     {
[15:32:47.800]         {
[15:32:47.800]             ...future.startTime <- base::Sys.time()
[15:32:47.800]             {
[15:32:47.800]                 {
[15:32:47.800]                   {
[15:32:47.800]                     {
[15:32:47.800]                       {
[15:32:47.800]                         base::local({
[15:32:47.800]                           has_future <- base::requireNamespace("future", 
[15:32:47.800]                             quietly = TRUE)
[15:32:47.800]                           if (has_future) {
[15:32:47.800]                             ns <- base::getNamespace("future")
[15:32:47.800]                             version <- ns[[".package"]][["version"]]
[15:32:47.800]                             if (is.null(version)) 
[15:32:47.800]                               version <- utils::packageVersion("future")
[15:32:47.800]                           }
[15:32:47.800]                           else {
[15:32:47.800]                             version <- NULL
[15:32:47.800]                           }
[15:32:47.800]                           if (!has_future || version < "1.8.0") {
[15:32:47.800]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:47.800]                               "", base::R.version$version.string), 
[15:32:47.800]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:47.800]                                 base::R.version$platform, 8 * 
[15:32:47.800]                                   base::.Machine$sizeof.pointer), 
[15:32:47.800]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:47.800]                                 "release", "version")], collapse = " "), 
[15:32:47.800]                               hostname = base::Sys.info()[["nodename"]])
[15:32:47.800]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:47.800]                               info)
[15:32:47.800]                             info <- base::paste(info, collapse = "; ")
[15:32:47.800]                             if (!has_future) {
[15:32:47.800]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:47.800]                                 info)
[15:32:47.800]                             }
[15:32:47.800]                             else {
[15:32:47.800]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:47.800]                                 info, version)
[15:32:47.800]                             }
[15:32:47.800]                             base::stop(msg)
[15:32:47.800]                           }
[15:32:47.800]                         })
[15:32:47.800]                       }
[15:32:47.800]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:47.800]                       base::options(mc.cores = 1L)
[15:32:47.800]                     }
[15:32:47.800]                     base::local({
[15:32:47.800]                       for (pkg in "future.apply") {
[15:32:47.800]                         base::loadNamespace(pkg)
[15:32:47.800]                         base::library(pkg, character.only = TRUE)
[15:32:47.800]                       }
[15:32:47.800]                     })
[15:32:47.800]                   }
[15:32:47.800]                   ...future.strategy.old <- future::plan("list")
[15:32:47.800]                   options(future.plan = NULL)
[15:32:47.800]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:47.800]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:47.800]                 }
[15:32:47.800]                 ...future.workdir <- getwd()
[15:32:47.800]             }
[15:32:47.800]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:47.800]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:47.800]         }
[15:32:47.800]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:47.800]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:47.800]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:47.800]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:47.800]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:47.800]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:47.800]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:47.800]             base::names(...future.oldOptions))
[15:32:47.800]     }
[15:32:47.800]     if (FALSE) {
[15:32:47.800]     }
[15:32:47.800]     else {
[15:32:47.800]         if (TRUE) {
[15:32:47.800]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:47.800]                 open = "w")
[15:32:47.800]         }
[15:32:47.800]         else {
[15:32:47.800]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:47.800]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:47.800]         }
[15:32:47.800]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:47.800]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:47.800]             base::sink(type = "output", split = FALSE)
[15:32:47.800]             base::close(...future.stdout)
[15:32:47.800]         }, add = TRUE)
[15:32:47.800]     }
[15:32:47.800]     ...future.frame <- base::sys.nframe()
[15:32:47.800]     ...future.conditions <- base::list()
[15:32:47.800]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:47.800]     if (FALSE) {
[15:32:47.800]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:47.800]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:47.800]     }
[15:32:47.800]     ...future.result <- base::tryCatch({
[15:32:47.800]         base::withCallingHandlers({
[15:32:47.800]             ...future.value <- base::withVisible(base::local({
[15:32:47.800]                 ...future.makeSendCondition <- base::local({
[15:32:47.800]                   sendCondition <- NULL
[15:32:47.800]                   function(frame = 1L) {
[15:32:47.800]                     if (is.function(sendCondition)) 
[15:32:47.800]                       return(sendCondition)
[15:32:47.800]                     ns <- getNamespace("parallel")
[15:32:47.800]                     if (exists("sendData", mode = "function", 
[15:32:47.800]                       envir = ns)) {
[15:32:47.800]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:47.800]                         envir = ns)
[15:32:47.800]                       envir <- sys.frame(frame)
[15:32:47.800]                       master <- NULL
[15:32:47.800]                       while (!identical(envir, .GlobalEnv) && 
[15:32:47.800]                         !identical(envir, emptyenv())) {
[15:32:47.800]                         if (exists("master", mode = "list", envir = envir, 
[15:32:47.800]                           inherits = FALSE)) {
[15:32:47.800]                           master <- get("master", mode = "list", 
[15:32:47.800]                             envir = envir, inherits = FALSE)
[15:32:47.800]                           if (inherits(master, c("SOCKnode", 
[15:32:47.800]                             "SOCK0node"))) {
[15:32:47.800]                             sendCondition <<- function(cond) {
[15:32:47.800]                               data <- list(type = "VALUE", value = cond, 
[15:32:47.800]                                 success = TRUE)
[15:32:47.800]                               parallel_sendData(master, data)
[15:32:47.800]                             }
[15:32:47.800]                             return(sendCondition)
[15:32:47.800]                           }
[15:32:47.800]                         }
[15:32:47.800]                         frame <- frame + 1L
[15:32:47.800]                         envir <- sys.frame(frame)
[15:32:47.800]                       }
[15:32:47.800]                     }
[15:32:47.800]                     sendCondition <<- function(cond) NULL
[15:32:47.800]                   }
[15:32:47.800]                 })
[15:32:47.800]                 withCallingHandlers({
[15:32:47.800]                   {
[15:32:47.800]                     do.call(function(...) {
[15:32:47.800]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.800]                       if (!identical(...future.globals.maxSize.org, 
[15:32:47.800]                         ...future.globals.maxSize)) {
[15:32:47.800]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.800]                         on.exit(options(oopts), add = TRUE)
[15:32:47.800]                       }
[15:32:47.800]                       {
[15:32:47.800]                         lapply(seq_along(...future.elements_ii), 
[15:32:47.800]                           FUN = function(jj) {
[15:32:47.800]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.800]                             ...future.FUN(...future.X_jj, ...)
[15:32:47.800]                           })
[15:32:47.800]                       }
[15:32:47.800]                     }, args = future.call.arguments)
[15:32:47.800]                   }
[15:32:47.800]                 }, immediateCondition = function(cond) {
[15:32:47.800]                   sendCondition <- ...future.makeSendCondition()
[15:32:47.800]                   sendCondition(cond)
[15:32:47.800]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.800]                   {
[15:32:47.800]                     inherits <- base::inherits
[15:32:47.800]                     invokeRestart <- base::invokeRestart
[15:32:47.800]                     is.null <- base::is.null
[15:32:47.800]                     muffled <- FALSE
[15:32:47.800]                     if (inherits(cond, "message")) {
[15:32:47.800]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:47.800]                       if (muffled) 
[15:32:47.800]                         invokeRestart("muffleMessage")
[15:32:47.800]                     }
[15:32:47.800]                     else if (inherits(cond, "warning")) {
[15:32:47.800]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:47.800]                       if (muffled) 
[15:32:47.800]                         invokeRestart("muffleWarning")
[15:32:47.800]                     }
[15:32:47.800]                     else if (inherits(cond, "condition")) {
[15:32:47.800]                       if (!is.null(pattern)) {
[15:32:47.800]                         computeRestarts <- base::computeRestarts
[15:32:47.800]                         grepl <- base::grepl
[15:32:47.800]                         restarts <- computeRestarts(cond)
[15:32:47.800]                         for (restart in restarts) {
[15:32:47.800]                           name <- restart$name
[15:32:47.800]                           if (is.null(name)) 
[15:32:47.800]                             next
[15:32:47.800]                           if (!grepl(pattern, name)) 
[15:32:47.800]                             next
[15:32:47.800]                           invokeRestart(restart)
[15:32:47.800]                           muffled <- TRUE
[15:32:47.800]                           break
[15:32:47.800]                         }
[15:32:47.800]                       }
[15:32:47.800]                     }
[15:32:47.800]                     invisible(muffled)
[15:32:47.800]                   }
[15:32:47.800]                   muffleCondition(cond)
[15:32:47.800]                 })
[15:32:47.800]             }))
[15:32:47.800]             future::FutureResult(value = ...future.value$value, 
[15:32:47.800]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:47.800]                   ...future.rng), globalenv = if (FALSE) 
[15:32:47.800]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:47.800]                     ...future.globalenv.names))
[15:32:47.800]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:47.800]         }, condition = base::local({
[15:32:47.800]             c <- base::c
[15:32:47.800]             inherits <- base::inherits
[15:32:47.800]             invokeRestart <- base::invokeRestart
[15:32:47.800]             length <- base::length
[15:32:47.800]             list <- base::list
[15:32:47.800]             seq.int <- base::seq.int
[15:32:47.800]             signalCondition <- base::signalCondition
[15:32:47.800]             sys.calls <- base::sys.calls
[15:32:47.800]             `[[` <- base::`[[`
[15:32:47.800]             `+` <- base::`+`
[15:32:47.800]             `<<-` <- base::`<<-`
[15:32:47.800]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:47.800]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:47.800]                   3L)]
[15:32:47.800]             }
[15:32:47.800]             function(cond) {
[15:32:47.800]                 is_error <- inherits(cond, "error")
[15:32:47.800]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:47.800]                   NULL)
[15:32:47.800]                 if (is_error) {
[15:32:47.800]                   sessionInformation <- function() {
[15:32:47.800]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:47.800]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:47.800]                       search = base::search(), system = base::Sys.info())
[15:32:47.800]                   }
[15:32:47.800]                   ...future.conditions[[length(...future.conditions) + 
[15:32:47.800]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:47.800]                     cond$call), session = sessionInformation(), 
[15:32:47.800]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:47.800]                   signalCondition(cond)
[15:32:47.800]                 }
[15:32:47.800]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:47.800]                 "immediateCondition"))) {
[15:32:47.800]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:47.800]                   ...future.conditions[[length(...future.conditions) + 
[15:32:47.800]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:47.800]                   if (TRUE && !signal) {
[15:32:47.800]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.800]                     {
[15:32:47.800]                       inherits <- base::inherits
[15:32:47.800]                       invokeRestart <- base::invokeRestart
[15:32:47.800]                       is.null <- base::is.null
[15:32:47.800]                       muffled <- FALSE
[15:32:47.800]                       if (inherits(cond, "message")) {
[15:32:47.800]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:47.800]                         if (muffled) 
[15:32:47.800]                           invokeRestart("muffleMessage")
[15:32:47.800]                       }
[15:32:47.800]                       else if (inherits(cond, "warning")) {
[15:32:47.800]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:47.800]                         if (muffled) 
[15:32:47.800]                           invokeRestart("muffleWarning")
[15:32:47.800]                       }
[15:32:47.800]                       else if (inherits(cond, "condition")) {
[15:32:47.800]                         if (!is.null(pattern)) {
[15:32:47.800]                           computeRestarts <- base::computeRestarts
[15:32:47.800]                           grepl <- base::grepl
[15:32:47.800]                           restarts <- computeRestarts(cond)
[15:32:47.800]                           for (restart in restarts) {
[15:32:47.800]                             name <- restart$name
[15:32:47.800]                             if (is.null(name)) 
[15:32:47.800]                               next
[15:32:47.800]                             if (!grepl(pattern, name)) 
[15:32:47.800]                               next
[15:32:47.800]                             invokeRestart(restart)
[15:32:47.800]                             muffled <- TRUE
[15:32:47.800]                             break
[15:32:47.800]                           }
[15:32:47.800]                         }
[15:32:47.800]                       }
[15:32:47.800]                       invisible(muffled)
[15:32:47.800]                     }
[15:32:47.800]                     muffleCondition(cond, pattern = "^muffle")
[15:32:47.800]                   }
[15:32:47.800]                 }
[15:32:47.800]                 else {
[15:32:47.800]                   if (TRUE) {
[15:32:47.800]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.800]                     {
[15:32:47.800]                       inherits <- base::inherits
[15:32:47.800]                       invokeRestart <- base::invokeRestart
[15:32:47.800]                       is.null <- base::is.null
[15:32:47.800]                       muffled <- FALSE
[15:32:47.800]                       if (inherits(cond, "message")) {
[15:32:47.800]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:47.800]                         if (muffled) 
[15:32:47.800]                           invokeRestart("muffleMessage")
[15:32:47.800]                       }
[15:32:47.800]                       else if (inherits(cond, "warning")) {
[15:32:47.800]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:47.800]                         if (muffled) 
[15:32:47.800]                           invokeRestart("muffleWarning")
[15:32:47.800]                       }
[15:32:47.800]                       else if (inherits(cond, "condition")) {
[15:32:47.800]                         if (!is.null(pattern)) {
[15:32:47.800]                           computeRestarts <- base::computeRestarts
[15:32:47.800]                           grepl <- base::grepl
[15:32:47.800]                           restarts <- computeRestarts(cond)
[15:32:47.800]                           for (restart in restarts) {
[15:32:47.800]                             name <- restart$name
[15:32:47.800]                             if (is.null(name)) 
[15:32:47.800]                               next
[15:32:47.800]                             if (!grepl(pattern, name)) 
[15:32:47.800]                               next
[15:32:47.800]                             invokeRestart(restart)
[15:32:47.800]                             muffled <- TRUE
[15:32:47.800]                             break
[15:32:47.800]                           }
[15:32:47.800]                         }
[15:32:47.800]                       }
[15:32:47.800]                       invisible(muffled)
[15:32:47.800]                     }
[15:32:47.800]                     muffleCondition(cond, pattern = "^muffle")
[15:32:47.800]                   }
[15:32:47.800]                 }
[15:32:47.800]             }
[15:32:47.800]         }))
[15:32:47.800]     }, error = function(ex) {
[15:32:47.800]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:47.800]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:47.800]                 ...future.rng), started = ...future.startTime, 
[15:32:47.800]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:47.800]             version = "1.8"), class = "FutureResult")
[15:32:47.800]     }, finally = {
[15:32:47.800]         if (!identical(...future.workdir, getwd())) 
[15:32:47.800]             setwd(...future.workdir)
[15:32:47.800]         {
[15:32:47.800]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:47.800]                 ...future.oldOptions$nwarnings <- NULL
[15:32:47.800]             }
[15:32:47.800]             base::options(...future.oldOptions)
[15:32:47.800]             if (.Platform$OS.type == "windows") {
[15:32:47.800]                 old_names <- names(...future.oldEnvVars)
[15:32:47.800]                 envs <- base::Sys.getenv()
[15:32:47.800]                 names <- names(envs)
[15:32:47.800]                 common <- intersect(names, old_names)
[15:32:47.800]                 added <- setdiff(names, old_names)
[15:32:47.800]                 removed <- setdiff(old_names, names)
[15:32:47.800]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:47.800]                   envs[common]]
[15:32:47.800]                 NAMES <- toupper(changed)
[15:32:47.800]                 args <- list()
[15:32:47.800]                 for (kk in seq_along(NAMES)) {
[15:32:47.800]                   name <- changed[[kk]]
[15:32:47.800]                   NAME <- NAMES[[kk]]
[15:32:47.800]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.800]                     next
[15:32:47.800]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:47.800]                 }
[15:32:47.800]                 NAMES <- toupper(added)
[15:32:47.800]                 for (kk in seq_along(NAMES)) {
[15:32:47.800]                   name <- added[[kk]]
[15:32:47.800]                   NAME <- NAMES[[kk]]
[15:32:47.800]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.800]                     next
[15:32:47.800]                   args[[name]] <- ""
[15:32:47.800]                 }
[15:32:47.800]                 NAMES <- toupper(removed)
[15:32:47.800]                 for (kk in seq_along(NAMES)) {
[15:32:47.800]                   name <- removed[[kk]]
[15:32:47.800]                   NAME <- NAMES[[kk]]
[15:32:47.800]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.800]                     next
[15:32:47.800]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:47.800]                 }
[15:32:47.800]                 if (length(args) > 0) 
[15:32:47.800]                   base::do.call(base::Sys.setenv, args = args)
[15:32:47.800]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:47.800]             }
[15:32:47.800]             else {
[15:32:47.800]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:47.800]             }
[15:32:47.800]             {
[15:32:47.800]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:47.800]                   0L) {
[15:32:47.800]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:47.800]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:47.800]                   base::options(opts)
[15:32:47.800]                 }
[15:32:47.800]                 {
[15:32:47.800]                   {
[15:32:47.800]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:47.800]                     NULL
[15:32:47.800]                   }
[15:32:47.800]                   options(future.plan = NULL)
[15:32:47.800]                   if (is.na(NA_character_)) 
[15:32:47.800]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:47.800]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:47.800]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:47.800]                     .init = FALSE)
[15:32:47.800]                 }
[15:32:47.800]             }
[15:32:47.800]         }
[15:32:47.800]     })
[15:32:47.800]     if (TRUE) {
[15:32:47.800]         base::sink(type = "output", split = FALSE)
[15:32:47.800]         if (TRUE) {
[15:32:47.800]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:47.800]         }
[15:32:47.800]         else {
[15:32:47.800]             ...future.result["stdout"] <- base::list(NULL)
[15:32:47.800]         }
[15:32:47.800]         base::close(...future.stdout)
[15:32:47.800]         ...future.stdout <- NULL
[15:32:47.800]     }
[15:32:47.800]     ...future.result$conditions <- ...future.conditions
[15:32:47.800]     ...future.result$finished <- base::Sys.time()
[15:32:47.800]     ...future.result
[15:32:47.800] }
[15:32:47.808] Exporting 11 global objects (93.16 KiB) to cluster node #1 ...
[15:32:47.808] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:47.809] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:47.810] Exporting 'x_FUN' (1.16 KiB) to cluster node #1 ...
[15:32:47.810] Exporting 'x_FUN' (1.16 KiB) to cluster node #1 ... DONE
[15:32:47.810] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:47.811] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:47.811] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:47.812] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:47.812] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:47.813] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:47.813] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:47.814] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:47.814] Exporting 'valid_types' (176 bytes) to cluster node #1 ...
[15:32:47.815] Exporting 'valid_types' (176 bytes) to cluster node #1 ... DONE
[15:32:47.815] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:47.816] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:47.816] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:47.817] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:47.817] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:47.817] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:47.818] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:47.818] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:47.819] Exporting 11 global objects (93.16 KiB) to cluster node #1 ... DONE
[15:32:47.819] MultisessionFuture started
[15:32:47.820] - Launch lazy future ... done
[15:32:47.820] run() for 'MultisessionFuture' ... done
[15:32:47.820] Created future:
[15:32:47.844] receiveMessageFromWorker() for ClusterFuture ...
[15:32:47.845] - Validating connection of MultisessionFuture
[15:32:47.845] - received message: FutureResult
[15:32:47.846] - Received FutureResult
[15:32:47.846] - Erased future from FutureRegistry
[15:32:47.846] result() for ClusterFuture ...
[15:32:47.846] - result already collected: FutureResult
[15:32:47.847] result() for ClusterFuture ... done
[15:32:47.847] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:47.821] MultisessionFuture:
[15:32:47.821] Label: 'future_vapply-1'
[15:32:47.821] Expression:
[15:32:47.821] {
[15:32:47.821]     do.call(function(...) {
[15:32:47.821]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.821]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.821]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.821]             on.exit(options(oopts), add = TRUE)
[15:32:47.821]         }
[15:32:47.821]         {
[15:32:47.821]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.821]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.821]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.821]             })
[15:32:47.821]         }
[15:32:47.821]     }, args = future.call.arguments)
[15:32:47.821] }
[15:32:47.821] Lazy evaluation: FALSE
[15:32:47.821] Asynchronous evaluation: TRUE
[15:32:47.821] Local evaluation: TRUE
[15:32:47.821] Environment: R_GlobalEnv
[15:32:47.821] Capture standard output: TRUE
[15:32:47.821] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:47.821] Globals: 11 objects totaling 93.44 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 1.16 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:47.821] Packages: 1 packages ('future.apply')
[15:32:47.821] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:47.821] Resolved: TRUE
[15:32:47.821] Value: <not collected>
[15:32:47.821] Conditions captured: <none>
[15:32:47.821] Early signaling: FALSE
[15:32:47.821] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:47.821] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:47.848] Chunk #1 of 2 ... DONE
[15:32:47.848] Chunk #2 of 2 ...
[15:32:47.848]  - Finding globals in 'X' for chunk #2 ...
[15:32:47.848] getGlobalsAndPackages() ...
[15:32:47.849] Searching for globals...
[15:32:47.849] 
[15:32:47.849] Searching for globals ... DONE
[15:32:47.850] - globals: [0] <none>
[15:32:47.850] getGlobalsAndPackages() ... DONE
[15:32:47.850]    + additional globals found: [n=0] 
[15:32:47.850]    + additional namespaces needed: [n=0] 
[15:32:47.851]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:47.851]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:47.851]  - seeds: <none>
[15:32:47.851]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.852] getGlobalsAndPackages() ...
[15:32:47.852] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.852] Resolving globals: FALSE
[15:32:47.852] Tweak future expression to call with '...' arguments ...
[15:32:47.853] {
[15:32:47.853]     do.call(function(...) {
[15:32:47.853]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.853]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.853]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.853]             on.exit(options(oopts), add = TRUE)
[15:32:47.853]         }
[15:32:47.853]         {
[15:32:47.853]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.853]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.853]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.853]             })
[15:32:47.853]         }
[15:32:47.853]     }, args = future.call.arguments)
[15:32:47.853] }
[15:32:47.853] Tweak future expression to call with '...' arguments ... DONE
[15:32:47.854] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.855] - packages: [1] 'future.apply'
[15:32:47.855] getGlobalsAndPackages() ... DONE
[15:32:47.856] run() for 'Future' ...
[15:32:47.856] - state: 'created'
[15:32:47.856] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:47.873] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:47.873] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:47.874]   - Field: 'node'
[15:32:47.874]   - Field: 'label'
[15:32:47.874]   - Field: 'local'
[15:32:47.874]   - Field: 'owner'
[15:32:47.875]   - Field: 'envir'
[15:32:47.875]   - Field: 'workers'
[15:32:47.875]   - Field: 'packages'
[15:32:47.875]   - Field: 'gc'
[15:32:47.876]   - Field: 'conditions'
[15:32:47.876]   - Field: 'persistent'
[15:32:47.876]   - Field: 'expr'
[15:32:47.877]   - Field: 'uuid'
[15:32:47.877]   - Field: 'seed'
[15:32:47.877]   - Field: 'version'
[15:32:47.877]   - Field: 'result'
[15:32:47.878]   - Field: 'asynchronous'
[15:32:47.878]   - Field: 'calls'
[15:32:47.878]   - Field: 'globals'
[15:32:47.878]   - Field: 'stdout'
[15:32:47.879]   - Field: 'earlySignal'
[15:32:47.879]   - Field: 'lazy'
[15:32:47.879]   - Field: 'state'
[15:32:47.879] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:47.880] - Launch lazy future ...
[15:32:47.880] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:47.881] Packages needed by future strategies (n = 0): <none>
[15:32:47.882] {
[15:32:47.882]     {
[15:32:47.882]         {
[15:32:47.882]             ...future.startTime <- base::Sys.time()
[15:32:47.882]             {
[15:32:47.882]                 {
[15:32:47.882]                   {
[15:32:47.882]                     {
[15:32:47.882]                       {
[15:32:47.882]                         base::local({
[15:32:47.882]                           has_future <- base::requireNamespace("future", 
[15:32:47.882]                             quietly = TRUE)
[15:32:47.882]                           if (has_future) {
[15:32:47.882]                             ns <- base::getNamespace("future")
[15:32:47.882]                             version <- ns[[".package"]][["version"]]
[15:32:47.882]                             if (is.null(version)) 
[15:32:47.882]                               version <- utils::packageVersion("future")
[15:32:47.882]                           }
[15:32:47.882]                           else {
[15:32:47.882]                             version <- NULL
[15:32:47.882]                           }
[15:32:47.882]                           if (!has_future || version < "1.8.0") {
[15:32:47.882]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:47.882]                               "", base::R.version$version.string), 
[15:32:47.882]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:47.882]                                 base::R.version$platform, 8 * 
[15:32:47.882]                                   base::.Machine$sizeof.pointer), 
[15:32:47.882]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:47.882]                                 "release", "version")], collapse = " "), 
[15:32:47.882]                               hostname = base::Sys.info()[["nodename"]])
[15:32:47.882]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:47.882]                               info)
[15:32:47.882]                             info <- base::paste(info, collapse = "; ")
[15:32:47.882]                             if (!has_future) {
[15:32:47.882]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:47.882]                                 info)
[15:32:47.882]                             }
[15:32:47.882]                             else {
[15:32:47.882]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:47.882]                                 info, version)
[15:32:47.882]                             }
[15:32:47.882]                             base::stop(msg)
[15:32:47.882]                           }
[15:32:47.882]                         })
[15:32:47.882]                       }
[15:32:47.882]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:47.882]                       base::options(mc.cores = 1L)
[15:32:47.882]                     }
[15:32:47.882]                     base::local({
[15:32:47.882]                       for (pkg in "future.apply") {
[15:32:47.882]                         base::loadNamespace(pkg)
[15:32:47.882]                         base::library(pkg, character.only = TRUE)
[15:32:47.882]                       }
[15:32:47.882]                     })
[15:32:47.882]                   }
[15:32:47.882]                   ...future.strategy.old <- future::plan("list")
[15:32:47.882]                   options(future.plan = NULL)
[15:32:47.882]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:47.882]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:47.882]                 }
[15:32:47.882]                 ...future.workdir <- getwd()
[15:32:47.882]             }
[15:32:47.882]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:47.882]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:47.882]         }
[15:32:47.882]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:47.882]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:47.882]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:47.882]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:47.882]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:47.882]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:47.882]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:47.882]             base::names(...future.oldOptions))
[15:32:47.882]     }
[15:32:47.882]     if (FALSE) {
[15:32:47.882]     }
[15:32:47.882]     else {
[15:32:47.882]         if (TRUE) {
[15:32:47.882]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:47.882]                 open = "w")
[15:32:47.882]         }
[15:32:47.882]         else {
[15:32:47.882]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:47.882]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:47.882]         }
[15:32:47.882]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:47.882]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:47.882]             base::sink(type = "output", split = FALSE)
[15:32:47.882]             base::close(...future.stdout)
[15:32:47.882]         }, add = TRUE)
[15:32:47.882]     }
[15:32:47.882]     ...future.frame <- base::sys.nframe()
[15:32:47.882]     ...future.conditions <- base::list()
[15:32:47.882]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:47.882]     if (FALSE) {
[15:32:47.882]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:47.882]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:47.882]     }
[15:32:47.882]     ...future.result <- base::tryCatch({
[15:32:47.882]         base::withCallingHandlers({
[15:32:47.882]             ...future.value <- base::withVisible(base::local({
[15:32:47.882]                 ...future.makeSendCondition <- base::local({
[15:32:47.882]                   sendCondition <- NULL
[15:32:47.882]                   function(frame = 1L) {
[15:32:47.882]                     if (is.function(sendCondition)) 
[15:32:47.882]                       return(sendCondition)
[15:32:47.882]                     ns <- getNamespace("parallel")
[15:32:47.882]                     if (exists("sendData", mode = "function", 
[15:32:47.882]                       envir = ns)) {
[15:32:47.882]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:47.882]                         envir = ns)
[15:32:47.882]                       envir <- sys.frame(frame)
[15:32:47.882]                       master <- NULL
[15:32:47.882]                       while (!identical(envir, .GlobalEnv) && 
[15:32:47.882]                         !identical(envir, emptyenv())) {
[15:32:47.882]                         if (exists("master", mode = "list", envir = envir, 
[15:32:47.882]                           inherits = FALSE)) {
[15:32:47.882]                           master <- get("master", mode = "list", 
[15:32:47.882]                             envir = envir, inherits = FALSE)
[15:32:47.882]                           if (inherits(master, c("SOCKnode", 
[15:32:47.882]                             "SOCK0node"))) {
[15:32:47.882]                             sendCondition <<- function(cond) {
[15:32:47.882]                               data <- list(type = "VALUE", value = cond, 
[15:32:47.882]                                 success = TRUE)
[15:32:47.882]                               parallel_sendData(master, data)
[15:32:47.882]                             }
[15:32:47.882]                             return(sendCondition)
[15:32:47.882]                           }
[15:32:47.882]                         }
[15:32:47.882]                         frame <- frame + 1L
[15:32:47.882]                         envir <- sys.frame(frame)
[15:32:47.882]                       }
[15:32:47.882]                     }
[15:32:47.882]                     sendCondition <<- function(cond) NULL
[15:32:47.882]                   }
[15:32:47.882]                 })
[15:32:47.882]                 withCallingHandlers({
[15:32:47.882]                   {
[15:32:47.882]                     do.call(function(...) {
[15:32:47.882]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.882]                       if (!identical(...future.globals.maxSize.org, 
[15:32:47.882]                         ...future.globals.maxSize)) {
[15:32:47.882]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.882]                         on.exit(options(oopts), add = TRUE)
[15:32:47.882]                       }
[15:32:47.882]                       {
[15:32:47.882]                         lapply(seq_along(...future.elements_ii), 
[15:32:47.882]                           FUN = function(jj) {
[15:32:47.882]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.882]                             ...future.FUN(...future.X_jj, ...)
[15:32:47.882]                           })
[15:32:47.882]                       }
[15:32:47.882]                     }, args = future.call.arguments)
[15:32:47.882]                   }
[15:32:47.882]                 }, immediateCondition = function(cond) {
[15:32:47.882]                   sendCondition <- ...future.makeSendCondition()
[15:32:47.882]                   sendCondition(cond)
[15:32:47.882]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.882]                   {
[15:32:47.882]                     inherits <- base::inherits
[15:32:47.882]                     invokeRestart <- base::invokeRestart
[15:32:47.882]                     is.null <- base::is.null
[15:32:47.882]                     muffled <- FALSE
[15:32:47.882]                     if (inherits(cond, "message")) {
[15:32:47.882]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:47.882]                       if (muffled) 
[15:32:47.882]                         invokeRestart("muffleMessage")
[15:32:47.882]                     }
[15:32:47.882]                     else if (inherits(cond, "warning")) {
[15:32:47.882]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:47.882]                       if (muffled) 
[15:32:47.882]                         invokeRestart("muffleWarning")
[15:32:47.882]                     }
[15:32:47.882]                     else if (inherits(cond, "condition")) {
[15:32:47.882]                       if (!is.null(pattern)) {
[15:32:47.882]                         computeRestarts <- base::computeRestarts
[15:32:47.882]                         grepl <- base::grepl
[15:32:47.882]                         restarts <- computeRestarts(cond)
[15:32:47.882]                         for (restart in restarts) {
[15:32:47.882]                           name <- restart$name
[15:32:47.882]                           if (is.null(name)) 
[15:32:47.882]                             next
[15:32:47.882]                           if (!grepl(pattern, name)) 
[15:32:47.882]                             next
[15:32:47.882]                           invokeRestart(restart)
[15:32:47.882]                           muffled <- TRUE
[15:32:47.882]                           break
[15:32:47.882]                         }
[15:32:47.882]                       }
[15:32:47.882]                     }
[15:32:47.882]                     invisible(muffled)
[15:32:47.882]                   }
[15:32:47.882]                   muffleCondition(cond)
[15:32:47.882]                 })
[15:32:47.882]             }))
[15:32:47.882]             future::FutureResult(value = ...future.value$value, 
[15:32:47.882]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:47.882]                   ...future.rng), globalenv = if (FALSE) 
[15:32:47.882]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:47.882]                     ...future.globalenv.names))
[15:32:47.882]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:47.882]         }, condition = base::local({
[15:32:47.882]             c <- base::c
[15:32:47.882]             inherits <- base::inherits
[15:32:47.882]             invokeRestart <- base::invokeRestart
[15:32:47.882]             length <- base::length
[15:32:47.882]             list <- base::list
[15:32:47.882]             seq.int <- base::seq.int
[15:32:47.882]             signalCondition <- base::signalCondition
[15:32:47.882]             sys.calls <- base::sys.calls
[15:32:47.882]             `[[` <- base::`[[`
[15:32:47.882]             `+` <- base::`+`
[15:32:47.882]             `<<-` <- base::`<<-`
[15:32:47.882]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:47.882]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:47.882]                   3L)]
[15:32:47.882]             }
[15:32:47.882]             function(cond) {
[15:32:47.882]                 is_error <- inherits(cond, "error")
[15:32:47.882]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:47.882]                   NULL)
[15:32:47.882]                 if (is_error) {
[15:32:47.882]                   sessionInformation <- function() {
[15:32:47.882]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:47.882]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:47.882]                       search = base::search(), system = base::Sys.info())
[15:32:47.882]                   }
[15:32:47.882]                   ...future.conditions[[length(...future.conditions) + 
[15:32:47.882]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:47.882]                     cond$call), session = sessionInformation(), 
[15:32:47.882]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:47.882]                   signalCondition(cond)
[15:32:47.882]                 }
[15:32:47.882]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:47.882]                 "immediateCondition"))) {
[15:32:47.882]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:47.882]                   ...future.conditions[[length(...future.conditions) + 
[15:32:47.882]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:47.882]                   if (TRUE && !signal) {
[15:32:47.882]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.882]                     {
[15:32:47.882]                       inherits <- base::inherits
[15:32:47.882]                       invokeRestart <- base::invokeRestart
[15:32:47.882]                       is.null <- base::is.null
[15:32:47.882]                       muffled <- FALSE
[15:32:47.882]                       if (inherits(cond, "message")) {
[15:32:47.882]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:47.882]                         if (muffled) 
[15:32:47.882]                           invokeRestart("muffleMessage")
[15:32:47.882]                       }
[15:32:47.882]                       else if (inherits(cond, "warning")) {
[15:32:47.882]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:47.882]                         if (muffled) 
[15:32:47.882]                           invokeRestart("muffleWarning")
[15:32:47.882]                       }
[15:32:47.882]                       else if (inherits(cond, "condition")) {
[15:32:47.882]                         if (!is.null(pattern)) {
[15:32:47.882]                           computeRestarts <- base::computeRestarts
[15:32:47.882]                           grepl <- base::grepl
[15:32:47.882]                           restarts <- computeRestarts(cond)
[15:32:47.882]                           for (restart in restarts) {
[15:32:47.882]                             name <- restart$name
[15:32:47.882]                             if (is.null(name)) 
[15:32:47.882]                               next
[15:32:47.882]                             if (!grepl(pattern, name)) 
[15:32:47.882]                               next
[15:32:47.882]                             invokeRestart(restart)
[15:32:47.882]                             muffled <- TRUE
[15:32:47.882]                             break
[15:32:47.882]                           }
[15:32:47.882]                         }
[15:32:47.882]                       }
[15:32:47.882]                       invisible(muffled)
[15:32:47.882]                     }
[15:32:47.882]                     muffleCondition(cond, pattern = "^muffle")
[15:32:47.882]                   }
[15:32:47.882]                 }
[15:32:47.882]                 else {
[15:32:47.882]                   if (TRUE) {
[15:32:47.882]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:47.882]                     {
[15:32:47.882]                       inherits <- base::inherits
[15:32:47.882]                       invokeRestart <- base::invokeRestart
[15:32:47.882]                       is.null <- base::is.null
[15:32:47.882]                       muffled <- FALSE
[15:32:47.882]                       if (inherits(cond, "message")) {
[15:32:47.882]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:47.882]                         if (muffled) 
[15:32:47.882]                           invokeRestart("muffleMessage")
[15:32:47.882]                       }
[15:32:47.882]                       else if (inherits(cond, "warning")) {
[15:32:47.882]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:47.882]                         if (muffled) 
[15:32:47.882]                           invokeRestart("muffleWarning")
[15:32:47.882]                       }
[15:32:47.882]                       else if (inherits(cond, "condition")) {
[15:32:47.882]                         if (!is.null(pattern)) {
[15:32:47.882]                           computeRestarts <- base::computeRestarts
[15:32:47.882]                           grepl <- base::grepl
[15:32:47.882]                           restarts <- computeRestarts(cond)
[15:32:47.882]                           for (restart in restarts) {
[15:32:47.882]                             name <- restart$name
[15:32:47.882]                             if (is.null(name)) 
[15:32:47.882]                               next
[15:32:47.882]                             if (!grepl(pattern, name)) 
[15:32:47.882]                               next
[15:32:47.882]                             invokeRestart(restart)
[15:32:47.882]                             muffled <- TRUE
[15:32:47.882]                             break
[15:32:47.882]                           }
[15:32:47.882]                         }
[15:32:47.882]                       }
[15:32:47.882]                       invisible(muffled)
[15:32:47.882]                     }
[15:32:47.882]                     muffleCondition(cond, pattern = "^muffle")
[15:32:47.882]                   }
[15:32:47.882]                 }
[15:32:47.882]             }
[15:32:47.882]         }))
[15:32:47.882]     }, error = function(ex) {
[15:32:47.882]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:47.882]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:47.882]                 ...future.rng), started = ...future.startTime, 
[15:32:47.882]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:47.882]             version = "1.8"), class = "FutureResult")
[15:32:47.882]     }, finally = {
[15:32:47.882]         if (!identical(...future.workdir, getwd())) 
[15:32:47.882]             setwd(...future.workdir)
[15:32:47.882]         {
[15:32:47.882]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:47.882]                 ...future.oldOptions$nwarnings <- NULL
[15:32:47.882]             }
[15:32:47.882]             base::options(...future.oldOptions)
[15:32:47.882]             if (.Platform$OS.type == "windows") {
[15:32:47.882]                 old_names <- names(...future.oldEnvVars)
[15:32:47.882]                 envs <- base::Sys.getenv()
[15:32:47.882]                 names <- names(envs)
[15:32:47.882]                 common <- intersect(names, old_names)
[15:32:47.882]                 added <- setdiff(names, old_names)
[15:32:47.882]                 removed <- setdiff(old_names, names)
[15:32:47.882]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:47.882]                   envs[common]]
[15:32:47.882]                 NAMES <- toupper(changed)
[15:32:47.882]                 args <- list()
[15:32:47.882]                 for (kk in seq_along(NAMES)) {
[15:32:47.882]                   name <- changed[[kk]]
[15:32:47.882]                   NAME <- NAMES[[kk]]
[15:32:47.882]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.882]                     next
[15:32:47.882]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:47.882]                 }
[15:32:47.882]                 NAMES <- toupper(added)
[15:32:47.882]                 for (kk in seq_along(NAMES)) {
[15:32:47.882]                   name <- added[[kk]]
[15:32:47.882]                   NAME <- NAMES[[kk]]
[15:32:47.882]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.882]                     next
[15:32:47.882]                   args[[name]] <- ""
[15:32:47.882]                 }
[15:32:47.882]                 NAMES <- toupper(removed)
[15:32:47.882]                 for (kk in seq_along(NAMES)) {
[15:32:47.882]                   name <- removed[[kk]]
[15:32:47.882]                   NAME <- NAMES[[kk]]
[15:32:47.882]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:47.882]                     next
[15:32:47.882]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:47.882]                 }
[15:32:47.882]                 if (length(args) > 0) 
[15:32:47.882]                   base::do.call(base::Sys.setenv, args = args)
[15:32:47.882]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:47.882]             }
[15:32:47.882]             else {
[15:32:47.882]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:47.882]             }
[15:32:47.882]             {
[15:32:47.882]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:47.882]                   0L) {
[15:32:47.882]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:47.882]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:47.882]                   base::options(opts)
[15:32:47.882]                 }
[15:32:47.882]                 {
[15:32:47.882]                   {
[15:32:47.882]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:47.882]                     NULL
[15:32:47.882]                   }
[15:32:47.882]                   options(future.plan = NULL)
[15:32:47.882]                   if (is.na(NA_character_)) 
[15:32:47.882]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:47.882]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:47.882]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:47.882]                     .init = FALSE)
[15:32:47.882]                 }
[15:32:47.882]             }
[15:32:47.882]         }
[15:32:47.882]     })
[15:32:47.882]     if (TRUE) {
[15:32:47.882]         base::sink(type = "output", split = FALSE)
[15:32:47.882]         if (TRUE) {
[15:32:47.882]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:47.882]         }
[15:32:47.882]         else {
[15:32:47.882]             ...future.result["stdout"] <- base::list(NULL)
[15:32:47.882]         }
[15:32:47.882]         base::close(...future.stdout)
[15:32:47.882]         ...future.stdout <- NULL
[15:32:47.882]     }
[15:32:47.882]     ...future.result$conditions <- ...future.conditions
[15:32:47.882]     ...future.result$finished <- base::Sys.time()
[15:32:47.882]     ...future.result
[15:32:47.882] }
[15:32:47.889] Exporting 11 global objects (93.16 KiB) to cluster node #1 ...
[15:32:47.890] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:47.891] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:47.891] Exporting 'x_FUN' (1.16 KiB) to cluster node #1 ...
[15:32:47.892] Exporting 'x_FUN' (1.16 KiB) to cluster node #1 ... DONE
[15:32:47.892] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:47.893] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:47.893] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:47.894] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:47.894] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:47.895] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:47.895] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:47.896] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:47.896] Exporting 'valid_types' (176 bytes) to cluster node #1 ...
[15:32:47.897] Exporting 'valid_types' (176 bytes) to cluster node #1 ... DONE
[15:32:47.897] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:47.898] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:47.898] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:47.898] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:47.899] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:47.899] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:47.900] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:47.900] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:47.900] Exporting 11 global objects (93.16 KiB) to cluster node #1 ... DONE
[15:32:47.901] MultisessionFuture started
[15:32:47.902] - Launch lazy future ... done
[15:32:47.902] run() for 'MultisessionFuture' ... done
[15:32:47.902] Created future:
[15:32:47.928] receiveMessageFromWorker() for ClusterFuture ...
[15:32:47.928] - Validating connection of MultisessionFuture
[15:32:47.929] - received message: FutureResult
[15:32:47.929] - Received FutureResult
[15:32:47.929] - Erased future from FutureRegistry
[15:32:47.929] result() for ClusterFuture ...
[15:32:47.930] - result already collected: FutureResult
[15:32:47.930] result() for ClusterFuture ... done
[15:32:47.930] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:47.902] MultisessionFuture:
[15:32:47.902] Label: 'future_vapply-2'
[15:32:47.902] Expression:
[15:32:47.902] {
[15:32:47.902]     do.call(function(...) {
[15:32:47.902]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.902]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.902]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.902]             on.exit(options(oopts), add = TRUE)
[15:32:47.902]         }
[15:32:47.902]         {
[15:32:47.902]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.902]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.902]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.902]             })
[15:32:47.902]         }
[15:32:47.902]     }, args = future.call.arguments)
[15:32:47.902] }
[15:32:47.902] Lazy evaluation: FALSE
[15:32:47.902] Asynchronous evaluation: TRUE
[15:32:47.902] Local evaluation: TRUE
[15:32:47.902] Environment: R_GlobalEnv
[15:32:47.902] Capture standard output: TRUE
[15:32:47.902] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:47.902] Globals: 11 objects totaling 93.44 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 1.16 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:47.902] Packages: 1 packages ('future.apply')
[15:32:47.902] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:47.902] Resolved: TRUE
[15:32:47.902] Value: <not collected>
[15:32:47.902] Conditions captured: <none>
[15:32:47.902] Early signaling: FALSE
[15:32:47.902] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:47.902] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:47.930] Chunk #2 of 2 ... DONE
[15:32:47.931] Launching 2 futures (chunks) ... DONE
[15:32:47.931] Resolving 2 futures (chunks) ...
[15:32:47.931] resolve() on list ...
[15:32:47.931]  recursive: 0
[15:32:47.931]  length: 2
[15:32:47.932] 
[15:32:47.932] Future #1
[15:32:47.932] result() for ClusterFuture ...
[15:32:47.932] - result already collected: FutureResult
[15:32:47.932] result() for ClusterFuture ... done
[15:32:47.932] result() for ClusterFuture ...
[15:32:47.933] - result already collected: FutureResult
[15:32:47.933] result() for ClusterFuture ... done
[15:32:47.933] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:47.933] - nx: 2
[15:32:47.933] - relay: TRUE
[15:32:47.933] - stdout: TRUE
[15:32:47.934] - signal: TRUE
[15:32:47.934] - resignal: FALSE
[15:32:47.934] - force: TRUE
[15:32:47.934] - relayed: [n=2] FALSE, FALSE
[15:32:47.934] - queued futures: [n=2] FALSE, FALSE
[15:32:47.934]  - until=1
[15:32:47.935]  - relaying element #1
[15:32:47.935] result() for ClusterFuture ...
[15:32:47.935] - result already collected: FutureResult
[15:32:47.935] result() for ClusterFuture ... done
[15:32:47.935] result() for ClusterFuture ...
[15:32:47.935] - result already collected: FutureResult
[15:32:47.936] result() for ClusterFuture ... done
[15:32:47.936] result() for ClusterFuture ...
[15:32:47.936] - result already collected: FutureResult
[15:32:47.936] result() for ClusterFuture ... done
[15:32:47.936] result() for ClusterFuture ...
[15:32:47.936] - result already collected: FutureResult
[15:32:47.937] result() for ClusterFuture ... done
[15:32:47.937] - relayed: [n=2] TRUE, FALSE
[15:32:47.937] - queued futures: [n=2] TRUE, FALSE
[15:32:47.937] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:47.937]  length: 1 (resolved future 1)
[15:32:47.938] Future #2
[15:32:47.938] result() for ClusterFuture ...
[15:32:47.938] - result already collected: FutureResult
[15:32:47.938] result() for ClusterFuture ... done
[15:32:47.938] result() for ClusterFuture ...
[15:32:47.938] - result already collected: FutureResult
[15:32:47.939] result() for ClusterFuture ... done
[15:32:47.939] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:47.939] - nx: 2
[15:32:47.939] - relay: TRUE
[15:32:47.939] - stdout: TRUE
[15:32:47.939] - signal: TRUE
[15:32:47.940] - resignal: FALSE
[15:32:47.940] - force: TRUE
[15:32:47.940] - relayed: [n=2] TRUE, FALSE
[15:32:47.940] - queued futures: [n=2] TRUE, FALSE
[15:32:47.940]  - until=2
[15:32:47.940]  - relaying element #2
[15:32:47.941] result() for ClusterFuture ...
[15:32:47.941] - result already collected: FutureResult
[15:32:47.941] result() for ClusterFuture ... done
[15:32:47.941] result() for ClusterFuture ...
[15:32:47.941] - result already collected: FutureResult
[15:32:47.941] result() for ClusterFuture ... done
[15:32:47.942] result() for ClusterFuture ...
[15:32:47.942] - result already collected: FutureResult
[15:32:47.942] result() for ClusterFuture ... done
[15:32:47.942] result() for ClusterFuture ...
[15:32:47.942] - result already collected: FutureResult
[15:32:47.942] result() for ClusterFuture ... done
[15:32:47.943] - relayed: [n=2] TRUE, TRUE
[15:32:47.943] - queued futures: [n=2] TRUE, TRUE
[15:32:47.943] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:47.943]  length: 0 (resolved future 2)
[15:32:47.943] Relaying remaining futures
[15:32:47.943] signalConditionsASAP(NULL, pos=0) ...
[15:32:47.944] - nx: 2
[15:32:47.944] - relay: TRUE
[15:32:47.944] - stdout: TRUE
[15:32:47.944] - signal: TRUE
[15:32:47.944] - resignal: FALSE
[15:32:47.944] - force: TRUE
[15:32:47.944] - relayed: [n=2] TRUE, TRUE
[15:32:47.945] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:47.945] - relayed: [n=2] TRUE, TRUE
[15:32:47.947] - queued futures: [n=2] TRUE, TRUE
[15:32:47.948] signalConditionsASAP(NULL, pos=0) ... done
[15:32:47.948] resolve() on list ... DONE
[15:32:47.948] result() for ClusterFuture ...
[15:32:47.948] - result already collected: FutureResult
[15:32:47.948] result() for ClusterFuture ... done
[15:32:47.948] result() for ClusterFuture ...
[15:32:47.949] - result already collected: FutureResult
[15:32:47.949] result() for ClusterFuture ... done
[15:32:47.949] result() for ClusterFuture ...
[15:32:47.949] - result already collected: FutureResult
[15:32:47.949] result() for ClusterFuture ... done
[15:32:47.949] result() for ClusterFuture ...
[15:32:47.950] - result already collected: FutureResult
[15:32:47.950] result() for ClusterFuture ... done
[15:32:47.950]  - Number of value chunks collected: 2
[15:32:47.950] Resolving 2 futures (chunks) ... DONE
[15:32:47.950] Reducing values from 2 chunks ...
[15:32:47.950]  - Number of values collected after concatenation: 10
[15:32:47.951]  - Number of values expected: 10
[15:32:47.951] Reducing values from 2 chunks ... DONE
[15:32:47.951] future_lapply() ... DONE
 int[0 , 1:10] 
 num [1:10] 1 1.41 1.73 2 2.24 ...
[15:32:47.952] future_lapply() ...
[15:32:47.957] Number of chunks: 2
[15:32:47.958] getGlobalsAndPackagesXApply() ...
[15:32:47.958]  - future.globals: TRUE
[15:32:47.958] getGlobalsAndPackages() ...
[15:32:47.958] Searching for globals...
[15:32:47.962] - globals found: [16] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types'
[15:32:47.962] Searching for globals ... DONE
[15:32:47.963] Resolving globals: FALSE
[15:32:47.964] The total size of the 7 globals is 92.12 KiB (94336 bytes)
[15:32:47.964] The total size of the 7 globals exported for future expression ('FUN()') is 92.12 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:47.965] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:47.965] - packages: [1] 'future.apply'
[15:32:47.965] getGlobalsAndPackages() ... DONE
[15:32:47.965]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:47.965]  - needed namespaces: [n=1] 'future.apply'
[15:32:47.965] Finding globals ... DONE
[15:32:47.966]  - use_args: TRUE
[15:32:47.966]  - Getting '...' globals ...
[15:32:47.966] resolve() on list ...
[15:32:47.966]  recursive: 0
[15:32:47.967]  length: 1
[15:32:47.967]  elements: '...'
[15:32:47.967]  length: 0 (resolved future 1)
[15:32:47.967] resolve() on list ... DONE
[15:32:47.967]    - '...' content: [n=0] 
[15:32:47.967] List of 1
[15:32:47.967]  $ ...: list()
[15:32:47.967]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:47.967]  - attr(*, "where")=List of 1
[15:32:47.967]   ..$ ...:<environment: 0x0000022d3e990b58> 
[15:32:47.967]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:47.967]  - attr(*, "resolved")= logi TRUE
[15:32:47.967]  - attr(*, "total_size")= num NA
[15:32:47.972]  - Getting '...' globals ... DONE
[15:32:47.972] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:47.973] List of 8
[15:32:47.973]  $ ...future.FUN:function (x, ...)  
[15:32:47.973]  $ x_FUN        :function (x)  
[15:32:47.973]  $ times        : int 1
[15:32:47.973]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:47.973]  $ stop_if_not  :function (...)  
[15:32:47.973]  $ dim          : NULL
[15:32:47.973]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:47.973]  $ ...          : list()
[15:32:47.973]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:47.973]  - attr(*, "where")=List of 8
[15:32:47.973]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:47.973]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:47.973]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:47.973]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:47.973]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:47.973]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:47.973]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:47.973]   ..$ ...          :<environment: 0x0000022d3e990b58> 
[15:32:47.973]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:47.973]  - attr(*, "resolved")= logi FALSE
[15:32:47.973]  - attr(*, "total_size")= num 94336
[15:32:47.983] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:47.983] getGlobalsAndPackagesXApply() ... DONE
[15:32:47.984] Number of futures (= number of chunks): 2
[15:32:47.984] Launching 2 futures (chunks) ...
[15:32:47.984] Chunk #1 of 2 ...
[15:32:47.985]  - Finding globals in 'X' for chunk #1 ...
[15:32:47.985] getGlobalsAndPackages() ...
[15:32:47.985] Searching for globals...
[15:32:47.986] 
[15:32:47.986] Searching for globals ... DONE
[15:32:47.986] - globals: [0] <none>
[15:32:47.986] getGlobalsAndPackages() ... DONE
[15:32:47.987]    + additional globals found: [n=0] 
[15:32:47.987]    + additional namespaces needed: [n=0] 
[15:32:47.987]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:47.988]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:47.988]  - seeds: <none>
[15:32:47.988]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.988] getGlobalsAndPackages() ...
[15:32:47.989] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.989] Resolving globals: FALSE
[15:32:47.989] Tweak future expression to call with '...' arguments ...
[15:32:47.990] {
[15:32:47.990]     do.call(function(...) {
[15:32:47.990]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:47.990]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:47.990]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:47.990]             on.exit(options(oopts), add = TRUE)
[15:32:47.990]         }
[15:32:47.990]         {
[15:32:47.990]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:47.990]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:47.990]                 ...future.FUN(...future.X_jj, ...)
[15:32:47.990]             })
[15:32:47.990]         }
[15:32:47.990]     }, args = future.call.arguments)
[15:32:47.990] }
[15:32:47.990] Tweak future expression to call with '...' arguments ... DONE
[15:32:47.991] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:47.992] - packages: [1] 'future.apply'
[15:32:47.992] getGlobalsAndPackages() ... DONE
[15:32:47.993] run() for 'Future' ...
[15:32:47.993] - state: 'created'
[15:32:47.993] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:48.011] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.011] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:48.012]   - Field: 'node'
[15:32:48.012]   - Field: 'label'
[15:32:48.012]   - Field: 'local'
[15:32:48.013]   - Field: 'owner'
[15:32:48.013]   - Field: 'envir'
[15:32:48.013]   - Field: 'workers'
[15:32:48.013]   - Field: 'packages'
[15:32:48.014]   - Field: 'gc'
[15:32:48.014]   - Field: 'conditions'
[15:32:48.014]   - Field: 'persistent'
[15:32:48.015]   - Field: 'expr'
[15:32:48.015]   - Field: 'uuid'
[15:32:48.015]   - Field: 'seed'
[15:32:48.016]   - Field: 'version'
[15:32:48.016]   - Field: 'result'
[15:32:48.017]   - Field: 'asynchronous'
[15:32:48.017]   - Field: 'calls'
[15:32:48.017]   - Field: 'globals'
[15:32:48.018]   - Field: 'stdout'
[15:32:48.018]   - Field: 'earlySignal'
[15:32:48.018]   - Field: 'lazy'
[15:32:48.019]   - Field: 'state'
[15:32:48.019] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:48.020] - Launch lazy future ...
[15:32:48.020] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:48.021] Packages needed by future strategies (n = 0): <none>
[15:32:48.022] {
[15:32:48.022]     {
[15:32:48.022]         {
[15:32:48.022]             ...future.startTime <- base::Sys.time()
[15:32:48.022]             {
[15:32:48.022]                 {
[15:32:48.022]                   {
[15:32:48.022]                     {
[15:32:48.022]                       {
[15:32:48.022]                         base::local({
[15:32:48.022]                           has_future <- base::requireNamespace("future", 
[15:32:48.022]                             quietly = TRUE)
[15:32:48.022]                           if (has_future) {
[15:32:48.022]                             ns <- base::getNamespace("future")
[15:32:48.022]                             version <- ns[[".package"]][["version"]]
[15:32:48.022]                             if (is.null(version)) 
[15:32:48.022]                               version <- utils::packageVersion("future")
[15:32:48.022]                           }
[15:32:48.022]                           else {
[15:32:48.022]                             version <- NULL
[15:32:48.022]                           }
[15:32:48.022]                           if (!has_future || version < "1.8.0") {
[15:32:48.022]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:48.022]                               "", base::R.version$version.string), 
[15:32:48.022]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:48.022]                                 base::R.version$platform, 8 * 
[15:32:48.022]                                   base::.Machine$sizeof.pointer), 
[15:32:48.022]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:48.022]                                 "release", "version")], collapse = " "), 
[15:32:48.022]                               hostname = base::Sys.info()[["nodename"]])
[15:32:48.022]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:48.022]                               info)
[15:32:48.022]                             info <- base::paste(info, collapse = "; ")
[15:32:48.022]                             if (!has_future) {
[15:32:48.022]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:48.022]                                 info)
[15:32:48.022]                             }
[15:32:48.022]                             else {
[15:32:48.022]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:48.022]                                 info, version)
[15:32:48.022]                             }
[15:32:48.022]                             base::stop(msg)
[15:32:48.022]                           }
[15:32:48.022]                         })
[15:32:48.022]                       }
[15:32:48.022]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:48.022]                       base::options(mc.cores = 1L)
[15:32:48.022]                     }
[15:32:48.022]                     base::local({
[15:32:48.022]                       for (pkg in "future.apply") {
[15:32:48.022]                         base::loadNamespace(pkg)
[15:32:48.022]                         base::library(pkg, character.only = TRUE)
[15:32:48.022]                       }
[15:32:48.022]                     })
[15:32:48.022]                   }
[15:32:48.022]                   ...future.strategy.old <- future::plan("list")
[15:32:48.022]                   options(future.plan = NULL)
[15:32:48.022]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.022]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:48.022]                 }
[15:32:48.022]                 ...future.workdir <- getwd()
[15:32:48.022]             }
[15:32:48.022]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:48.022]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:48.022]         }
[15:32:48.022]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:48.022]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:48.022]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:48.022]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:48.022]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:48.022]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:48.022]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:48.022]             base::names(...future.oldOptions))
[15:32:48.022]     }
[15:32:48.022]     if (FALSE) {
[15:32:48.022]     }
[15:32:48.022]     else {
[15:32:48.022]         if (TRUE) {
[15:32:48.022]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:48.022]                 open = "w")
[15:32:48.022]         }
[15:32:48.022]         else {
[15:32:48.022]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:48.022]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:48.022]         }
[15:32:48.022]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:48.022]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:48.022]             base::sink(type = "output", split = FALSE)
[15:32:48.022]             base::close(...future.stdout)
[15:32:48.022]         }, add = TRUE)
[15:32:48.022]     }
[15:32:48.022]     ...future.frame <- base::sys.nframe()
[15:32:48.022]     ...future.conditions <- base::list()
[15:32:48.022]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:48.022]     if (FALSE) {
[15:32:48.022]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:48.022]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:48.022]     }
[15:32:48.022]     ...future.result <- base::tryCatch({
[15:32:48.022]         base::withCallingHandlers({
[15:32:48.022]             ...future.value <- base::withVisible(base::local({
[15:32:48.022]                 ...future.makeSendCondition <- base::local({
[15:32:48.022]                   sendCondition <- NULL
[15:32:48.022]                   function(frame = 1L) {
[15:32:48.022]                     if (is.function(sendCondition)) 
[15:32:48.022]                       return(sendCondition)
[15:32:48.022]                     ns <- getNamespace("parallel")
[15:32:48.022]                     if (exists("sendData", mode = "function", 
[15:32:48.022]                       envir = ns)) {
[15:32:48.022]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:48.022]                         envir = ns)
[15:32:48.022]                       envir <- sys.frame(frame)
[15:32:48.022]                       master <- NULL
[15:32:48.022]                       while (!identical(envir, .GlobalEnv) && 
[15:32:48.022]                         !identical(envir, emptyenv())) {
[15:32:48.022]                         if (exists("master", mode = "list", envir = envir, 
[15:32:48.022]                           inherits = FALSE)) {
[15:32:48.022]                           master <- get("master", mode = "list", 
[15:32:48.022]                             envir = envir, inherits = FALSE)
[15:32:48.022]                           if (inherits(master, c("SOCKnode", 
[15:32:48.022]                             "SOCK0node"))) {
[15:32:48.022]                             sendCondition <<- function(cond) {
[15:32:48.022]                               data <- list(type = "VALUE", value = cond, 
[15:32:48.022]                                 success = TRUE)
[15:32:48.022]                               parallel_sendData(master, data)
[15:32:48.022]                             }
[15:32:48.022]                             return(sendCondition)
[15:32:48.022]                           }
[15:32:48.022]                         }
[15:32:48.022]                         frame <- frame + 1L
[15:32:48.022]                         envir <- sys.frame(frame)
[15:32:48.022]                       }
[15:32:48.022]                     }
[15:32:48.022]                     sendCondition <<- function(cond) NULL
[15:32:48.022]                   }
[15:32:48.022]                 })
[15:32:48.022]                 withCallingHandlers({
[15:32:48.022]                   {
[15:32:48.022]                     do.call(function(...) {
[15:32:48.022]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.022]                       if (!identical(...future.globals.maxSize.org, 
[15:32:48.022]                         ...future.globals.maxSize)) {
[15:32:48.022]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.022]                         on.exit(options(oopts), add = TRUE)
[15:32:48.022]                       }
[15:32:48.022]                       {
[15:32:48.022]                         lapply(seq_along(...future.elements_ii), 
[15:32:48.022]                           FUN = function(jj) {
[15:32:48.022]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.022]                             ...future.FUN(...future.X_jj, ...)
[15:32:48.022]                           })
[15:32:48.022]                       }
[15:32:48.022]                     }, args = future.call.arguments)
[15:32:48.022]                   }
[15:32:48.022]                 }, immediateCondition = function(cond) {
[15:32:48.022]                   sendCondition <- ...future.makeSendCondition()
[15:32:48.022]                   sendCondition(cond)
[15:32:48.022]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.022]                   {
[15:32:48.022]                     inherits <- base::inherits
[15:32:48.022]                     invokeRestart <- base::invokeRestart
[15:32:48.022]                     is.null <- base::is.null
[15:32:48.022]                     muffled <- FALSE
[15:32:48.022]                     if (inherits(cond, "message")) {
[15:32:48.022]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:48.022]                       if (muffled) 
[15:32:48.022]                         invokeRestart("muffleMessage")
[15:32:48.022]                     }
[15:32:48.022]                     else if (inherits(cond, "warning")) {
[15:32:48.022]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:48.022]                       if (muffled) 
[15:32:48.022]                         invokeRestart("muffleWarning")
[15:32:48.022]                     }
[15:32:48.022]                     else if (inherits(cond, "condition")) {
[15:32:48.022]                       if (!is.null(pattern)) {
[15:32:48.022]                         computeRestarts <- base::computeRestarts
[15:32:48.022]                         grepl <- base::grepl
[15:32:48.022]                         restarts <- computeRestarts(cond)
[15:32:48.022]                         for (restart in restarts) {
[15:32:48.022]                           name <- restart$name
[15:32:48.022]                           if (is.null(name)) 
[15:32:48.022]                             next
[15:32:48.022]                           if (!grepl(pattern, name)) 
[15:32:48.022]                             next
[15:32:48.022]                           invokeRestart(restart)
[15:32:48.022]                           muffled <- TRUE
[15:32:48.022]                           break
[15:32:48.022]                         }
[15:32:48.022]                       }
[15:32:48.022]                     }
[15:32:48.022]                     invisible(muffled)
[15:32:48.022]                   }
[15:32:48.022]                   muffleCondition(cond)
[15:32:48.022]                 })
[15:32:48.022]             }))
[15:32:48.022]             future::FutureResult(value = ...future.value$value, 
[15:32:48.022]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.022]                   ...future.rng), globalenv = if (FALSE) 
[15:32:48.022]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:48.022]                     ...future.globalenv.names))
[15:32:48.022]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:48.022]         }, condition = base::local({
[15:32:48.022]             c <- base::c
[15:32:48.022]             inherits <- base::inherits
[15:32:48.022]             invokeRestart <- base::invokeRestart
[15:32:48.022]             length <- base::length
[15:32:48.022]             list <- base::list
[15:32:48.022]             seq.int <- base::seq.int
[15:32:48.022]             signalCondition <- base::signalCondition
[15:32:48.022]             sys.calls <- base::sys.calls
[15:32:48.022]             `[[` <- base::`[[`
[15:32:48.022]             `+` <- base::`+`
[15:32:48.022]             `<<-` <- base::`<<-`
[15:32:48.022]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:48.022]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:48.022]                   3L)]
[15:32:48.022]             }
[15:32:48.022]             function(cond) {
[15:32:48.022]                 is_error <- inherits(cond, "error")
[15:32:48.022]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:48.022]                   NULL)
[15:32:48.022]                 if (is_error) {
[15:32:48.022]                   sessionInformation <- function() {
[15:32:48.022]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:48.022]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:48.022]                       search = base::search(), system = base::Sys.info())
[15:32:48.022]                   }
[15:32:48.022]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.022]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:48.022]                     cond$call), session = sessionInformation(), 
[15:32:48.022]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:48.022]                   signalCondition(cond)
[15:32:48.022]                 }
[15:32:48.022]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:48.022]                 "immediateCondition"))) {
[15:32:48.022]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:48.022]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.022]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:48.022]                   if (TRUE && !signal) {
[15:32:48.022]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.022]                     {
[15:32:48.022]                       inherits <- base::inherits
[15:32:48.022]                       invokeRestart <- base::invokeRestart
[15:32:48.022]                       is.null <- base::is.null
[15:32:48.022]                       muffled <- FALSE
[15:32:48.022]                       if (inherits(cond, "message")) {
[15:32:48.022]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.022]                         if (muffled) 
[15:32:48.022]                           invokeRestart("muffleMessage")
[15:32:48.022]                       }
[15:32:48.022]                       else if (inherits(cond, "warning")) {
[15:32:48.022]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.022]                         if (muffled) 
[15:32:48.022]                           invokeRestart("muffleWarning")
[15:32:48.022]                       }
[15:32:48.022]                       else if (inherits(cond, "condition")) {
[15:32:48.022]                         if (!is.null(pattern)) {
[15:32:48.022]                           computeRestarts <- base::computeRestarts
[15:32:48.022]                           grepl <- base::grepl
[15:32:48.022]                           restarts <- computeRestarts(cond)
[15:32:48.022]                           for (restart in restarts) {
[15:32:48.022]                             name <- restart$name
[15:32:48.022]                             if (is.null(name)) 
[15:32:48.022]                               next
[15:32:48.022]                             if (!grepl(pattern, name)) 
[15:32:48.022]                               next
[15:32:48.022]                             invokeRestart(restart)
[15:32:48.022]                             muffled <- TRUE
[15:32:48.022]                             break
[15:32:48.022]                           }
[15:32:48.022]                         }
[15:32:48.022]                       }
[15:32:48.022]                       invisible(muffled)
[15:32:48.022]                     }
[15:32:48.022]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.022]                   }
[15:32:48.022]                 }
[15:32:48.022]                 else {
[15:32:48.022]                   if (TRUE) {
[15:32:48.022]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.022]                     {
[15:32:48.022]                       inherits <- base::inherits
[15:32:48.022]                       invokeRestart <- base::invokeRestart
[15:32:48.022]                       is.null <- base::is.null
[15:32:48.022]                       muffled <- FALSE
[15:32:48.022]                       if (inherits(cond, "message")) {
[15:32:48.022]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.022]                         if (muffled) 
[15:32:48.022]                           invokeRestart("muffleMessage")
[15:32:48.022]                       }
[15:32:48.022]                       else if (inherits(cond, "warning")) {
[15:32:48.022]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.022]                         if (muffled) 
[15:32:48.022]                           invokeRestart("muffleWarning")
[15:32:48.022]                       }
[15:32:48.022]                       else if (inherits(cond, "condition")) {
[15:32:48.022]                         if (!is.null(pattern)) {
[15:32:48.022]                           computeRestarts <- base::computeRestarts
[15:32:48.022]                           grepl <- base::grepl
[15:32:48.022]                           restarts <- computeRestarts(cond)
[15:32:48.022]                           for (restart in restarts) {
[15:32:48.022]                             name <- restart$name
[15:32:48.022]                             if (is.null(name)) 
[15:32:48.022]                               next
[15:32:48.022]                             if (!grepl(pattern, name)) 
[15:32:48.022]                               next
[15:32:48.022]                             invokeRestart(restart)
[15:32:48.022]                             muffled <- TRUE
[15:32:48.022]                             break
[15:32:48.022]                           }
[15:32:48.022]                         }
[15:32:48.022]                       }
[15:32:48.022]                       invisible(muffled)
[15:32:48.022]                     }
[15:32:48.022]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.022]                   }
[15:32:48.022]                 }
[15:32:48.022]             }
[15:32:48.022]         }))
[15:32:48.022]     }, error = function(ex) {
[15:32:48.022]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:48.022]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.022]                 ...future.rng), started = ...future.startTime, 
[15:32:48.022]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:48.022]             version = "1.8"), class = "FutureResult")
[15:32:48.022]     }, finally = {
[15:32:48.022]         if (!identical(...future.workdir, getwd())) 
[15:32:48.022]             setwd(...future.workdir)
[15:32:48.022]         {
[15:32:48.022]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:48.022]                 ...future.oldOptions$nwarnings <- NULL
[15:32:48.022]             }
[15:32:48.022]             base::options(...future.oldOptions)
[15:32:48.022]             if (.Platform$OS.type == "windows") {
[15:32:48.022]                 old_names <- names(...future.oldEnvVars)
[15:32:48.022]                 envs <- base::Sys.getenv()
[15:32:48.022]                 names <- names(envs)
[15:32:48.022]                 common <- intersect(names, old_names)
[15:32:48.022]                 added <- setdiff(names, old_names)
[15:32:48.022]                 removed <- setdiff(old_names, names)
[15:32:48.022]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:48.022]                   envs[common]]
[15:32:48.022]                 NAMES <- toupper(changed)
[15:32:48.022]                 args <- list()
[15:32:48.022]                 for (kk in seq_along(NAMES)) {
[15:32:48.022]                   name <- changed[[kk]]
[15:32:48.022]                   NAME <- NAMES[[kk]]
[15:32:48.022]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.022]                     next
[15:32:48.022]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.022]                 }
[15:32:48.022]                 NAMES <- toupper(added)
[15:32:48.022]                 for (kk in seq_along(NAMES)) {
[15:32:48.022]                   name <- added[[kk]]
[15:32:48.022]                   NAME <- NAMES[[kk]]
[15:32:48.022]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.022]                     next
[15:32:48.022]                   args[[name]] <- ""
[15:32:48.022]                 }
[15:32:48.022]                 NAMES <- toupper(removed)
[15:32:48.022]                 for (kk in seq_along(NAMES)) {
[15:32:48.022]                   name <- removed[[kk]]
[15:32:48.022]                   NAME <- NAMES[[kk]]
[15:32:48.022]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.022]                     next
[15:32:48.022]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.022]                 }
[15:32:48.022]                 if (length(args) > 0) 
[15:32:48.022]                   base::do.call(base::Sys.setenv, args = args)
[15:32:48.022]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:48.022]             }
[15:32:48.022]             else {
[15:32:48.022]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:48.022]             }
[15:32:48.022]             {
[15:32:48.022]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:48.022]                   0L) {
[15:32:48.022]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:48.022]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:48.022]                   base::options(opts)
[15:32:48.022]                 }
[15:32:48.022]                 {
[15:32:48.022]                   {
[15:32:48.022]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:48.022]                     NULL
[15:32:48.022]                   }
[15:32:48.022]                   options(future.plan = NULL)
[15:32:48.022]                   if (is.na(NA_character_)) 
[15:32:48.022]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.022]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:48.022]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:48.022]                     .init = FALSE)
[15:32:48.022]                 }
[15:32:48.022]             }
[15:32:48.022]         }
[15:32:48.022]     })
[15:32:48.022]     if (TRUE) {
[15:32:48.022]         base::sink(type = "output", split = FALSE)
[15:32:48.022]         if (TRUE) {
[15:32:48.022]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:48.022]         }
[15:32:48.022]         else {
[15:32:48.022]             ...future.result["stdout"] <- base::list(NULL)
[15:32:48.022]         }
[15:32:48.022]         base::close(...future.stdout)
[15:32:48.022]         ...future.stdout <- NULL
[15:32:48.022]     }
[15:32:48.022]     ...future.result$conditions <- ...future.conditions
[15:32:48.022]     ...future.result$finished <- base::Sys.time()
[15:32:48.022]     ...future.result
[15:32:48.022] }
[15:32:48.033] Exporting 11 global objects (92.12 KiB) to cluster node #1 ...
[15:32:48.033] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:48.034] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:48.034] Exporting 'x_FUN' (56 bytes) to cluster node #1 ...
[15:32:48.035] Exporting 'x_FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:48.036] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:48.036] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:48.037] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:48.037] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:48.038] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:48.038] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:48.038] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:48.039] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:48.040] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:48.043] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:48.044] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:48.045] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:48.045] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:48.046] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:48.046] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:48.047] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:48.047] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:48.048] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:48.048] Exporting 11 global objects (92.12 KiB) to cluster node #1 ... DONE
[15:32:48.049] MultisessionFuture started
[15:32:48.050] - Launch lazy future ... done
[15:32:48.050] run() for 'MultisessionFuture' ... done
[15:32:48.050] Created future:
[15:32:48.068] receiveMessageFromWorker() for ClusterFuture ...
[15:32:48.068] - Validating connection of MultisessionFuture
[15:32:48.068] - received message: FutureResult
[15:32:48.069] - Received FutureResult
[15:32:48.069] - Erased future from FutureRegistry
[15:32:48.069] result() for ClusterFuture ...
[15:32:48.069] - result already collected: FutureResult
[15:32:48.070] result() for ClusterFuture ... done
[15:32:48.070] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:48.050] MultisessionFuture:
[15:32:48.050] Label: 'future_vapply-1'
[15:32:48.050] Expression:
[15:32:48.050] {
[15:32:48.050]     do.call(function(...) {
[15:32:48.050]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.050]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.050]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.050]             on.exit(options(oopts), add = TRUE)
[15:32:48.050]         }
[15:32:48.050]         {
[15:32:48.050]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.050]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.050]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.050]             })
[15:32:48.050]         }
[15:32:48.050]     }, args = future.call.arguments)
[15:32:48.050] }
[15:32:48.050] Lazy evaluation: FALSE
[15:32:48.050] Asynchronous evaluation: TRUE
[15:32:48.050] Local evaluation: TRUE
[15:32:48.050] Environment: R_GlobalEnv
[15:32:48.050] Capture standard output: TRUE
[15:32:48.050] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:48.050] Globals: 11 objects totaling 92.40 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 56 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:48.050] Packages: 1 packages ('future.apply')
[15:32:48.050] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:48.050] Resolved: TRUE
[15:32:48.050] Value: <not collected>
[15:32:48.050] Conditions captured: <none>
[15:32:48.050] Early signaling: FALSE
[15:32:48.050] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:48.050] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.071] Chunk #1 of 2 ... DONE
[15:32:48.071] Chunk #2 of 2 ...
[15:32:48.071]  - Finding globals in 'X' for chunk #2 ...
[15:32:48.071] getGlobalsAndPackages() ...
[15:32:48.072] Searching for globals...
[15:32:48.072] 
[15:32:48.072] Searching for globals ... DONE
[15:32:48.073] - globals: [0] <none>
[15:32:48.073] getGlobalsAndPackages() ... DONE
[15:32:48.073]    + additional globals found: [n=0] 
[15:32:48.074]    + additional namespaces needed: [n=0] 
[15:32:48.074]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:48.074]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:48.075]  - seeds: <none>
[15:32:48.075]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.076] getGlobalsAndPackages() ...
[15:32:48.076] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.076] Resolving globals: FALSE
[15:32:48.077] Tweak future expression to call with '...' arguments ...
[15:32:48.077] {
[15:32:48.077]     do.call(function(...) {
[15:32:48.077]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.077]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.077]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.077]             on.exit(options(oopts), add = TRUE)
[15:32:48.077]         }
[15:32:48.077]         {
[15:32:48.077]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.077]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.077]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.077]             })
[15:32:48.077]         }
[15:32:48.077]     }, args = future.call.arguments)
[15:32:48.077] }
[15:32:48.078] Tweak future expression to call with '...' arguments ... DONE
[15:32:48.079] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.080] - packages: [1] 'future.apply'
[15:32:48.080] getGlobalsAndPackages() ... DONE
[15:32:48.081] run() for 'Future' ...
[15:32:48.081] - state: 'created'
[15:32:48.082] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:48.101] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.101] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:48.101]   - Field: 'node'
[15:32:48.102]   - Field: 'label'
[15:32:48.102]   - Field: 'local'
[15:32:48.102]   - Field: 'owner'
[15:32:48.102]   - Field: 'envir'
[15:32:48.102]   - Field: 'workers'
[15:32:48.103]   - Field: 'packages'
[15:32:48.103]   - Field: 'gc'
[15:32:48.103]   - Field: 'conditions'
[15:32:48.103]   - Field: 'persistent'
[15:32:48.104]   - Field: 'expr'
[15:32:48.104]   - Field: 'uuid'
[15:32:48.104]   - Field: 'seed'
[15:32:48.104]   - Field: 'version'
[15:32:48.105]   - Field: 'result'
[15:32:48.105]   - Field: 'asynchronous'
[15:32:48.105]   - Field: 'calls'
[15:32:48.105]   - Field: 'globals'
[15:32:48.105]   - Field: 'stdout'
[15:32:48.106]   - Field: 'earlySignal'
[15:32:48.106]   - Field: 'lazy'
[15:32:48.106]   - Field: 'state'
[15:32:48.106] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:48.107] - Launch lazy future ...
[15:32:48.107] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:48.107] Packages needed by future strategies (n = 0): <none>
[15:32:48.108] {
[15:32:48.108]     {
[15:32:48.108]         {
[15:32:48.108]             ...future.startTime <- base::Sys.time()
[15:32:48.108]             {
[15:32:48.108]                 {
[15:32:48.108]                   {
[15:32:48.108]                     {
[15:32:48.108]                       {
[15:32:48.108]                         base::local({
[15:32:48.108]                           has_future <- base::requireNamespace("future", 
[15:32:48.108]                             quietly = TRUE)
[15:32:48.108]                           if (has_future) {
[15:32:48.108]                             ns <- base::getNamespace("future")
[15:32:48.108]                             version <- ns[[".package"]][["version"]]
[15:32:48.108]                             if (is.null(version)) 
[15:32:48.108]                               version <- utils::packageVersion("future")
[15:32:48.108]                           }
[15:32:48.108]                           else {
[15:32:48.108]                             version <- NULL
[15:32:48.108]                           }
[15:32:48.108]                           if (!has_future || version < "1.8.0") {
[15:32:48.108]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:48.108]                               "", base::R.version$version.string), 
[15:32:48.108]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:48.108]                                 base::R.version$platform, 8 * 
[15:32:48.108]                                   base::.Machine$sizeof.pointer), 
[15:32:48.108]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:48.108]                                 "release", "version")], collapse = " "), 
[15:32:48.108]                               hostname = base::Sys.info()[["nodename"]])
[15:32:48.108]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:48.108]                               info)
[15:32:48.108]                             info <- base::paste(info, collapse = "; ")
[15:32:48.108]                             if (!has_future) {
[15:32:48.108]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:48.108]                                 info)
[15:32:48.108]                             }
[15:32:48.108]                             else {
[15:32:48.108]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:48.108]                                 info, version)
[15:32:48.108]                             }
[15:32:48.108]                             base::stop(msg)
[15:32:48.108]                           }
[15:32:48.108]                         })
[15:32:48.108]                       }
[15:32:48.108]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:48.108]                       base::options(mc.cores = 1L)
[15:32:48.108]                     }
[15:32:48.108]                     base::local({
[15:32:48.108]                       for (pkg in "future.apply") {
[15:32:48.108]                         base::loadNamespace(pkg)
[15:32:48.108]                         base::library(pkg, character.only = TRUE)
[15:32:48.108]                       }
[15:32:48.108]                     })
[15:32:48.108]                   }
[15:32:48.108]                   ...future.strategy.old <- future::plan("list")
[15:32:48.108]                   options(future.plan = NULL)
[15:32:48.108]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.108]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:48.108]                 }
[15:32:48.108]                 ...future.workdir <- getwd()
[15:32:48.108]             }
[15:32:48.108]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:48.108]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:48.108]         }
[15:32:48.108]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:48.108]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:48.108]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:48.108]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:48.108]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:48.108]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:48.108]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:48.108]             base::names(...future.oldOptions))
[15:32:48.108]     }
[15:32:48.108]     if (FALSE) {
[15:32:48.108]     }
[15:32:48.108]     else {
[15:32:48.108]         if (TRUE) {
[15:32:48.108]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:48.108]                 open = "w")
[15:32:48.108]         }
[15:32:48.108]         else {
[15:32:48.108]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:48.108]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:48.108]         }
[15:32:48.108]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:48.108]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:48.108]             base::sink(type = "output", split = FALSE)
[15:32:48.108]             base::close(...future.stdout)
[15:32:48.108]         }, add = TRUE)
[15:32:48.108]     }
[15:32:48.108]     ...future.frame <- base::sys.nframe()
[15:32:48.108]     ...future.conditions <- base::list()
[15:32:48.108]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:48.108]     if (FALSE) {
[15:32:48.108]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:48.108]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:48.108]     }
[15:32:48.108]     ...future.result <- base::tryCatch({
[15:32:48.108]         base::withCallingHandlers({
[15:32:48.108]             ...future.value <- base::withVisible(base::local({
[15:32:48.108]                 ...future.makeSendCondition <- base::local({
[15:32:48.108]                   sendCondition <- NULL
[15:32:48.108]                   function(frame = 1L) {
[15:32:48.108]                     if (is.function(sendCondition)) 
[15:32:48.108]                       return(sendCondition)
[15:32:48.108]                     ns <- getNamespace("parallel")
[15:32:48.108]                     if (exists("sendData", mode = "function", 
[15:32:48.108]                       envir = ns)) {
[15:32:48.108]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:48.108]                         envir = ns)
[15:32:48.108]                       envir <- sys.frame(frame)
[15:32:48.108]                       master <- NULL
[15:32:48.108]                       while (!identical(envir, .GlobalEnv) && 
[15:32:48.108]                         !identical(envir, emptyenv())) {
[15:32:48.108]                         if (exists("master", mode = "list", envir = envir, 
[15:32:48.108]                           inherits = FALSE)) {
[15:32:48.108]                           master <- get("master", mode = "list", 
[15:32:48.108]                             envir = envir, inherits = FALSE)
[15:32:48.108]                           if (inherits(master, c("SOCKnode", 
[15:32:48.108]                             "SOCK0node"))) {
[15:32:48.108]                             sendCondition <<- function(cond) {
[15:32:48.108]                               data <- list(type = "VALUE", value = cond, 
[15:32:48.108]                                 success = TRUE)
[15:32:48.108]                               parallel_sendData(master, data)
[15:32:48.108]                             }
[15:32:48.108]                             return(sendCondition)
[15:32:48.108]                           }
[15:32:48.108]                         }
[15:32:48.108]                         frame <- frame + 1L
[15:32:48.108]                         envir <- sys.frame(frame)
[15:32:48.108]                       }
[15:32:48.108]                     }
[15:32:48.108]                     sendCondition <<- function(cond) NULL
[15:32:48.108]                   }
[15:32:48.108]                 })
[15:32:48.108]                 withCallingHandlers({
[15:32:48.108]                   {
[15:32:48.108]                     do.call(function(...) {
[15:32:48.108]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.108]                       if (!identical(...future.globals.maxSize.org, 
[15:32:48.108]                         ...future.globals.maxSize)) {
[15:32:48.108]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.108]                         on.exit(options(oopts), add = TRUE)
[15:32:48.108]                       }
[15:32:48.108]                       {
[15:32:48.108]                         lapply(seq_along(...future.elements_ii), 
[15:32:48.108]                           FUN = function(jj) {
[15:32:48.108]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.108]                             ...future.FUN(...future.X_jj, ...)
[15:32:48.108]                           })
[15:32:48.108]                       }
[15:32:48.108]                     }, args = future.call.arguments)
[15:32:48.108]                   }
[15:32:48.108]                 }, immediateCondition = function(cond) {
[15:32:48.108]                   sendCondition <- ...future.makeSendCondition()
[15:32:48.108]                   sendCondition(cond)
[15:32:48.108]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.108]                   {
[15:32:48.108]                     inherits <- base::inherits
[15:32:48.108]                     invokeRestart <- base::invokeRestart
[15:32:48.108]                     is.null <- base::is.null
[15:32:48.108]                     muffled <- FALSE
[15:32:48.108]                     if (inherits(cond, "message")) {
[15:32:48.108]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:48.108]                       if (muffled) 
[15:32:48.108]                         invokeRestart("muffleMessage")
[15:32:48.108]                     }
[15:32:48.108]                     else if (inherits(cond, "warning")) {
[15:32:48.108]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:48.108]                       if (muffled) 
[15:32:48.108]                         invokeRestart("muffleWarning")
[15:32:48.108]                     }
[15:32:48.108]                     else if (inherits(cond, "condition")) {
[15:32:48.108]                       if (!is.null(pattern)) {
[15:32:48.108]                         computeRestarts <- base::computeRestarts
[15:32:48.108]                         grepl <- base::grepl
[15:32:48.108]                         restarts <- computeRestarts(cond)
[15:32:48.108]                         for (restart in restarts) {
[15:32:48.108]                           name <- restart$name
[15:32:48.108]                           if (is.null(name)) 
[15:32:48.108]                             next
[15:32:48.108]                           if (!grepl(pattern, name)) 
[15:32:48.108]                             next
[15:32:48.108]                           invokeRestart(restart)
[15:32:48.108]                           muffled <- TRUE
[15:32:48.108]                           break
[15:32:48.108]                         }
[15:32:48.108]                       }
[15:32:48.108]                     }
[15:32:48.108]                     invisible(muffled)
[15:32:48.108]                   }
[15:32:48.108]                   muffleCondition(cond)
[15:32:48.108]                 })
[15:32:48.108]             }))
[15:32:48.108]             future::FutureResult(value = ...future.value$value, 
[15:32:48.108]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.108]                   ...future.rng), globalenv = if (FALSE) 
[15:32:48.108]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:48.108]                     ...future.globalenv.names))
[15:32:48.108]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:48.108]         }, condition = base::local({
[15:32:48.108]             c <- base::c
[15:32:48.108]             inherits <- base::inherits
[15:32:48.108]             invokeRestart <- base::invokeRestart
[15:32:48.108]             length <- base::length
[15:32:48.108]             list <- base::list
[15:32:48.108]             seq.int <- base::seq.int
[15:32:48.108]             signalCondition <- base::signalCondition
[15:32:48.108]             sys.calls <- base::sys.calls
[15:32:48.108]             `[[` <- base::`[[`
[15:32:48.108]             `+` <- base::`+`
[15:32:48.108]             `<<-` <- base::`<<-`
[15:32:48.108]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:48.108]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:48.108]                   3L)]
[15:32:48.108]             }
[15:32:48.108]             function(cond) {
[15:32:48.108]                 is_error <- inherits(cond, "error")
[15:32:48.108]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:48.108]                   NULL)
[15:32:48.108]                 if (is_error) {
[15:32:48.108]                   sessionInformation <- function() {
[15:32:48.108]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:48.108]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:48.108]                       search = base::search(), system = base::Sys.info())
[15:32:48.108]                   }
[15:32:48.108]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.108]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:48.108]                     cond$call), session = sessionInformation(), 
[15:32:48.108]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:48.108]                   signalCondition(cond)
[15:32:48.108]                 }
[15:32:48.108]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:48.108]                 "immediateCondition"))) {
[15:32:48.108]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:48.108]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.108]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:48.108]                   if (TRUE && !signal) {
[15:32:48.108]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.108]                     {
[15:32:48.108]                       inherits <- base::inherits
[15:32:48.108]                       invokeRestart <- base::invokeRestart
[15:32:48.108]                       is.null <- base::is.null
[15:32:48.108]                       muffled <- FALSE
[15:32:48.108]                       if (inherits(cond, "message")) {
[15:32:48.108]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.108]                         if (muffled) 
[15:32:48.108]                           invokeRestart("muffleMessage")
[15:32:48.108]                       }
[15:32:48.108]                       else if (inherits(cond, "warning")) {
[15:32:48.108]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.108]                         if (muffled) 
[15:32:48.108]                           invokeRestart("muffleWarning")
[15:32:48.108]                       }
[15:32:48.108]                       else if (inherits(cond, "condition")) {
[15:32:48.108]                         if (!is.null(pattern)) {
[15:32:48.108]                           computeRestarts <- base::computeRestarts
[15:32:48.108]                           grepl <- base::grepl
[15:32:48.108]                           restarts <- computeRestarts(cond)
[15:32:48.108]                           for (restart in restarts) {
[15:32:48.108]                             name <- restart$name
[15:32:48.108]                             if (is.null(name)) 
[15:32:48.108]                               next
[15:32:48.108]                             if (!grepl(pattern, name)) 
[15:32:48.108]                               next
[15:32:48.108]                             invokeRestart(restart)
[15:32:48.108]                             muffled <- TRUE
[15:32:48.108]                             break
[15:32:48.108]                           }
[15:32:48.108]                         }
[15:32:48.108]                       }
[15:32:48.108]                       invisible(muffled)
[15:32:48.108]                     }
[15:32:48.108]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.108]                   }
[15:32:48.108]                 }
[15:32:48.108]                 else {
[15:32:48.108]                   if (TRUE) {
[15:32:48.108]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.108]                     {
[15:32:48.108]                       inherits <- base::inherits
[15:32:48.108]                       invokeRestart <- base::invokeRestart
[15:32:48.108]                       is.null <- base::is.null
[15:32:48.108]                       muffled <- FALSE
[15:32:48.108]                       if (inherits(cond, "message")) {
[15:32:48.108]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.108]                         if (muffled) 
[15:32:48.108]                           invokeRestart("muffleMessage")
[15:32:48.108]                       }
[15:32:48.108]                       else if (inherits(cond, "warning")) {
[15:32:48.108]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.108]                         if (muffled) 
[15:32:48.108]                           invokeRestart("muffleWarning")
[15:32:48.108]                       }
[15:32:48.108]                       else if (inherits(cond, "condition")) {
[15:32:48.108]                         if (!is.null(pattern)) {
[15:32:48.108]                           computeRestarts <- base::computeRestarts
[15:32:48.108]                           grepl <- base::grepl
[15:32:48.108]                           restarts <- computeRestarts(cond)
[15:32:48.108]                           for (restart in restarts) {
[15:32:48.108]                             name <- restart$name
[15:32:48.108]                             if (is.null(name)) 
[15:32:48.108]                               next
[15:32:48.108]                             if (!grepl(pattern, name)) 
[15:32:48.108]                               next
[15:32:48.108]                             invokeRestart(restart)
[15:32:48.108]                             muffled <- TRUE
[15:32:48.108]                             break
[15:32:48.108]                           }
[15:32:48.108]                         }
[15:32:48.108]                       }
[15:32:48.108]                       invisible(muffled)
[15:32:48.108]                     }
[15:32:48.108]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.108]                   }
[15:32:48.108]                 }
[15:32:48.108]             }
[15:32:48.108]         }))
[15:32:48.108]     }, error = function(ex) {
[15:32:48.108]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:48.108]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.108]                 ...future.rng), started = ...future.startTime, 
[15:32:48.108]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:48.108]             version = "1.8"), class = "FutureResult")
[15:32:48.108]     }, finally = {
[15:32:48.108]         if (!identical(...future.workdir, getwd())) 
[15:32:48.108]             setwd(...future.workdir)
[15:32:48.108]         {
[15:32:48.108]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:48.108]                 ...future.oldOptions$nwarnings <- NULL
[15:32:48.108]             }
[15:32:48.108]             base::options(...future.oldOptions)
[15:32:48.108]             if (.Platform$OS.type == "windows") {
[15:32:48.108]                 old_names <- names(...future.oldEnvVars)
[15:32:48.108]                 envs <- base::Sys.getenv()
[15:32:48.108]                 names <- names(envs)
[15:32:48.108]                 common <- intersect(names, old_names)
[15:32:48.108]                 added <- setdiff(names, old_names)
[15:32:48.108]                 removed <- setdiff(old_names, names)
[15:32:48.108]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:48.108]                   envs[common]]
[15:32:48.108]                 NAMES <- toupper(changed)
[15:32:48.108]                 args <- list()
[15:32:48.108]                 for (kk in seq_along(NAMES)) {
[15:32:48.108]                   name <- changed[[kk]]
[15:32:48.108]                   NAME <- NAMES[[kk]]
[15:32:48.108]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.108]                     next
[15:32:48.108]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.108]                 }
[15:32:48.108]                 NAMES <- toupper(added)
[15:32:48.108]                 for (kk in seq_along(NAMES)) {
[15:32:48.108]                   name <- added[[kk]]
[15:32:48.108]                   NAME <- NAMES[[kk]]
[15:32:48.108]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.108]                     next
[15:32:48.108]                   args[[name]] <- ""
[15:32:48.108]                 }
[15:32:48.108]                 NAMES <- toupper(removed)
[15:32:48.108]                 for (kk in seq_along(NAMES)) {
[15:32:48.108]                   name <- removed[[kk]]
[15:32:48.108]                   NAME <- NAMES[[kk]]
[15:32:48.108]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.108]                     next
[15:32:48.108]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.108]                 }
[15:32:48.108]                 if (length(args) > 0) 
[15:32:48.108]                   base::do.call(base::Sys.setenv, args = args)
[15:32:48.108]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:48.108]             }
[15:32:48.108]             else {
[15:32:48.108]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:48.108]             }
[15:32:48.108]             {
[15:32:48.108]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:48.108]                   0L) {
[15:32:48.108]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:48.108]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:48.108]                   base::options(opts)
[15:32:48.108]                 }
[15:32:48.108]                 {
[15:32:48.108]                   {
[15:32:48.108]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:48.108]                     NULL
[15:32:48.108]                   }
[15:32:48.108]                   options(future.plan = NULL)
[15:32:48.108]                   if (is.na(NA_character_)) 
[15:32:48.108]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.108]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:48.108]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:48.108]                     .init = FALSE)
[15:32:48.108]                 }
[15:32:48.108]             }
[15:32:48.108]         }
[15:32:48.108]     })
[15:32:48.108]     if (TRUE) {
[15:32:48.108]         base::sink(type = "output", split = FALSE)
[15:32:48.108]         if (TRUE) {
[15:32:48.108]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:48.108]         }
[15:32:48.108]         else {
[15:32:48.108]             ...future.result["stdout"] <- base::list(NULL)
[15:32:48.108]         }
[15:32:48.108]         base::close(...future.stdout)
[15:32:48.108]         ...future.stdout <- NULL
[15:32:48.108]     }
[15:32:48.108]     ...future.result$conditions <- ...future.conditions
[15:32:48.108]     ...future.result$finished <- base::Sys.time()
[15:32:48.108]     ...future.result
[15:32:48.108] }
[15:32:48.115] Exporting 11 global objects (92.12 KiB) to cluster node #1 ...
[15:32:48.116] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:48.116] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:48.117] Exporting 'x_FUN' (56 bytes) to cluster node #1 ...
[15:32:48.117] Exporting 'x_FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:48.117] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:48.118] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:48.118] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:48.119] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:48.119] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:48.120] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:48.120] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:48.120] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:48.121] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:48.121] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:48.122] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:48.122] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:48.123] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:48.123] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:48.123] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:48.124] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:48.124] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:48.125] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:48.125] Exporting 11 global objects (92.12 KiB) to cluster node #1 ... DONE
[15:32:48.126] MultisessionFuture started
[15:32:48.126] - Launch lazy future ... done
[15:32:48.127] run() for 'MultisessionFuture' ... done
[15:32:48.127] Created future:
[15:32:48.156] receiveMessageFromWorker() for ClusterFuture ...
[15:32:48.156] - Validating connection of MultisessionFuture
[15:32:48.157] - received message: FutureResult
[15:32:48.157] - Received FutureResult
[15:32:48.157] - Erased future from FutureRegistry
[15:32:48.158] result() for ClusterFuture ...
[15:32:48.158] - result already collected: FutureResult
[15:32:48.158] result() for ClusterFuture ... done
[15:32:48.158] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:48.127] MultisessionFuture:
[15:32:48.127] Label: 'future_vapply-2'
[15:32:48.127] Expression:
[15:32:48.127] {
[15:32:48.127]     do.call(function(...) {
[15:32:48.127]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.127]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.127]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.127]             on.exit(options(oopts), add = TRUE)
[15:32:48.127]         }
[15:32:48.127]         {
[15:32:48.127]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.127]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.127]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.127]             })
[15:32:48.127]         }
[15:32:48.127]     }, args = future.call.arguments)
[15:32:48.127] }
[15:32:48.127] Lazy evaluation: FALSE
[15:32:48.127] Asynchronous evaluation: TRUE
[15:32:48.127] Local evaluation: TRUE
[15:32:48.127] Environment: R_GlobalEnv
[15:32:48.127] Capture standard output: TRUE
[15:32:48.127] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:48.127] Globals: 11 objects totaling 92.40 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 56 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:48.127] Packages: 1 packages ('future.apply')
[15:32:48.127] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:48.127] Resolved: TRUE
[15:32:48.127] Value: <not collected>
[15:32:48.127] Conditions captured: <none>
[15:32:48.127] Early signaling: FALSE
[15:32:48.127] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:48.127] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.159] Chunk #2 of 2 ... DONE
[15:32:48.160] Launching 2 futures (chunks) ... DONE
[15:32:48.160] Resolving 2 futures (chunks) ...
[15:32:48.160] resolve() on list ...
[15:32:48.160]  recursive: 0
[15:32:48.161]  length: 2
[15:32:48.161] 
[15:32:48.161] Future #1
[15:32:48.161] result() for ClusterFuture ...
[15:32:48.162] - result already collected: FutureResult
[15:32:48.162] result() for ClusterFuture ... done
[15:32:48.162] result() for ClusterFuture ...
[15:32:48.162] - result already collected: FutureResult
[15:32:48.163] result() for ClusterFuture ... done
[15:32:48.163] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:48.163] - nx: 2
[15:32:48.163] - relay: TRUE
[15:32:48.164] - stdout: TRUE
[15:32:48.164] - signal: TRUE
[15:32:48.164] - resignal: FALSE
[15:32:48.164] - force: TRUE
[15:32:48.165] - relayed: [n=2] FALSE, FALSE
[15:32:48.165] - queued futures: [n=2] FALSE, FALSE
[15:32:48.165]  - until=1
[15:32:48.165]  - relaying element #1
[15:32:48.166] result() for ClusterFuture ...
[15:32:48.166] - result already collected: FutureResult
[15:32:48.166] result() for ClusterFuture ... done
[15:32:48.166] result() for ClusterFuture ...
[15:32:48.167] - result already collected: FutureResult
[15:32:48.167] result() for ClusterFuture ... done
[15:32:48.167] result() for ClusterFuture ...
[15:32:48.168] - result already collected: FutureResult
[15:32:48.168] result() for ClusterFuture ... done
[15:32:48.168] result() for ClusterFuture ...
[15:32:48.168] - result already collected: FutureResult
[15:32:48.169] result() for ClusterFuture ... done
[15:32:48.169] - relayed: [n=2] TRUE, FALSE
[15:32:48.169] - queued futures: [n=2] TRUE, FALSE
[15:32:48.169] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:48.170]  length: 1 (resolved future 1)
[15:32:48.170] Future #2
[15:32:48.170] result() for ClusterFuture ...
[15:32:48.170] - result already collected: FutureResult
[15:32:48.171] result() for ClusterFuture ... done
[15:32:48.171] result() for ClusterFuture ...
[15:32:48.171] - result already collected: FutureResult
[15:32:48.171] result() for ClusterFuture ... done
[15:32:48.172] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:48.172] - nx: 2
[15:32:48.172] - relay: TRUE
[15:32:48.172] - stdout: TRUE
[15:32:48.173] - signal: TRUE
[15:32:48.173] - resignal: FALSE
[15:32:48.173] - force: TRUE
[15:32:48.173] - relayed: [n=2] TRUE, FALSE
[15:32:48.174] - queued futures: [n=2] TRUE, FALSE
[15:32:48.174]  - until=2
[15:32:48.174]  - relaying element #2
[15:32:48.175] result() for ClusterFuture ...
[15:32:48.175] - result already collected: FutureResult
[15:32:48.175] result() for ClusterFuture ... done
[15:32:48.175] result() for ClusterFuture ...
[15:32:48.176] - result already collected: FutureResult
[15:32:48.176] result() for ClusterFuture ... done
[15:32:48.176] result() for ClusterFuture ...
[15:32:48.176] - result already collected: FutureResult
[15:32:48.177] result() for ClusterFuture ... done
[15:32:48.177] result() for ClusterFuture ...
[15:32:48.177] - result already collected: FutureResult
[15:32:48.177] result() for ClusterFuture ... done
[15:32:48.178] - relayed: [n=2] TRUE, TRUE
[15:32:48.178] - queued futures: [n=2] TRUE, TRUE
[15:32:48.178] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:48.178]  length: 0 (resolved future 2)
[15:32:48.179] Relaying remaining futures
[15:32:48.179] signalConditionsASAP(NULL, pos=0) ...
[15:32:48.179] - nx: 2
[15:32:48.179] - relay: TRUE
[15:32:48.180] - stdout: TRUE
[15:32:48.180] - signal: TRUE
[15:32:48.180] - resignal: FALSE
[15:32:48.180] - force: TRUE
[15:32:48.181] - relayed: [n=2] TRUE, TRUE
[15:32:48.181] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:48.181] - relayed: [n=2] TRUE, TRUE
[15:32:48.182] - queued futures: [n=2] TRUE, TRUE
[15:32:48.182] signalConditionsASAP(NULL, pos=0) ... done
[15:32:48.182] resolve() on list ... DONE
[15:32:48.182] result() for ClusterFuture ...
[15:32:48.183] - result already collected: FutureResult
[15:32:48.183] result() for ClusterFuture ... done
[15:32:48.183] result() for ClusterFuture ...
[15:32:48.183] - result already collected: FutureResult
[15:32:48.184] result() for ClusterFuture ... done
[15:32:48.184] result() for ClusterFuture ...
[15:32:48.184] - result already collected: FutureResult
[15:32:48.184] result() for ClusterFuture ... done
[15:32:48.185] result() for ClusterFuture ...
[15:32:48.185] - result already collected: FutureResult
[15:32:48.185] result() for ClusterFuture ... done
[15:32:48.186]  - Number of value chunks collected: 2
[15:32:48.186] Resolving 2 futures (chunks) ... DONE
[15:32:48.186] Reducing values from 2 chunks ...
[15:32:48.186]  - Number of values collected after concatenation: 10
[15:32:48.187]  - Number of values expected: 10
[15:32:48.187] Reducing values from 2 chunks ... DONE
[15:32:48.187] future_lapply() ... DONE
 num [1:10] 1 1.41 1.73 2 2.24 ...
 num [1:2, 1:10] 1 1 2 4 3 9 4 16 5 25 ...
[15:32:48.189] future_lapply() ...
[15:32:48.196] Number of chunks: 2
[15:32:48.197] getGlobalsAndPackagesXApply() ...
[15:32:48.197]  - future.globals: TRUE
[15:32:48.197] getGlobalsAndPackages() ...
[15:32:48.197] Searching for globals...
[15:32:48.205] - globals found: [18] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'c', '^'
[15:32:48.205] Searching for globals ... DONE
[15:32:48.206] Resolving globals: FALSE
[15:32:48.211] The total size of the 7 globals is 94.20 KiB (96456 bytes)
[15:32:48.212] The total size of the 7 globals exported for future expression ('FUN()') is 94.20 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:48.212] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:48.212] - packages: [1] 'future.apply'
[15:32:48.213] getGlobalsAndPackages() ... DONE
[15:32:48.213]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:48.213]  - needed namespaces: [n=1] 'future.apply'
[15:32:48.214] Finding globals ... DONE
[15:32:48.214]  - use_args: TRUE
[15:32:48.214]  - Getting '...' globals ...
[15:32:48.215] resolve() on list ...
[15:32:48.215]  recursive: 0
[15:32:48.216]  length: 1
[15:32:48.216]  elements: '...'
[15:32:48.216]  length: 0 (resolved future 1)
[15:32:48.217] resolve() on list ... DONE
[15:32:48.217]    - '...' content: [n=0] 
[15:32:48.217] List of 1
[15:32:48.217]  $ ...: list()
[15:32:48.217]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:48.217]  - attr(*, "where")=List of 1
[15:32:48.217]   ..$ ...:<environment: 0x0000022d41faa860> 
[15:32:48.217]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:48.217]  - attr(*, "resolved")= logi TRUE
[15:32:48.217]  - attr(*, "total_size")= num NA
[15:32:48.223]  - Getting '...' globals ... DONE
[15:32:48.223] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:48.223] List of 8
[15:32:48.223]  $ ...future.FUN:function (x, ...)  
[15:32:48.223]  $ x_FUN        :function (x)  
[15:32:48.223]  $ times        : int 2
[15:32:48.223]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:48.223]  $ stop_if_not  :function (...)  
[15:32:48.223]  $ dim          : NULL
[15:32:48.223]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:48.223]  $ ...          : list()
[15:32:48.223]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:48.223]  - attr(*, "where")=List of 8
[15:32:48.223]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:48.223]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:48.223]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:48.223]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:48.223]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:48.223]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:48.223]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:48.223]   ..$ ...          :<environment: 0x0000022d41faa860> 
[15:32:48.223]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:48.223]  - attr(*, "resolved")= logi FALSE
[15:32:48.223]  - attr(*, "total_size")= num 96456
[15:32:48.235] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:48.236] getGlobalsAndPackagesXApply() ... DONE
[15:32:48.236] Number of futures (= number of chunks): 2
[15:32:48.236] Launching 2 futures (chunks) ...
[15:32:48.237] Chunk #1 of 2 ...
[15:32:48.237]  - Finding globals in 'X' for chunk #1 ...
[15:32:48.237] getGlobalsAndPackages() ...
[15:32:48.238] Searching for globals...
[15:32:48.238] 
[15:32:48.239] Searching for globals ... DONE
[15:32:48.239] - globals: [0] <none>
[15:32:48.239] getGlobalsAndPackages() ... DONE
[15:32:48.240]    + additional globals found: [n=0] 
[15:32:48.240]    + additional namespaces needed: [n=0] 
[15:32:48.240]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:48.240]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:48.241]  - seeds: <none>
[15:32:48.241]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.241] getGlobalsAndPackages() ...
[15:32:48.242] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.242] Resolving globals: FALSE
[15:32:48.242] Tweak future expression to call with '...' arguments ...
[15:32:48.243] {
[15:32:48.243]     do.call(function(...) {
[15:32:48.243]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.243]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.243]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.243]             on.exit(options(oopts), add = TRUE)
[15:32:48.243]         }
[15:32:48.243]         {
[15:32:48.243]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.243]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.243]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.243]             })
[15:32:48.243]         }
[15:32:48.243]     }, args = future.call.arguments)
[15:32:48.243] }
[15:32:48.244] Tweak future expression to call with '...' arguments ... DONE
[15:32:48.245] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.245] - packages: [1] 'future.apply'
[15:32:48.246] getGlobalsAndPackages() ... DONE
[15:32:48.246] run() for 'Future' ...
[15:32:48.247] - state: 'created'
[15:32:48.247] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:48.269] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.270] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:48.270]   - Field: 'node'
[15:32:48.271]   - Field: 'label'
[15:32:48.271]   - Field: 'local'
[15:32:48.271]   - Field: 'owner'
[15:32:48.272]   - Field: 'envir'
[15:32:48.272]   - Field: 'workers'
[15:32:48.272]   - Field: 'packages'
[15:32:48.273]   - Field: 'gc'
[15:32:48.273]   - Field: 'conditions'
[15:32:48.273]   - Field: 'persistent'
[15:32:48.274]   - Field: 'expr'
[15:32:48.274]   - Field: 'uuid'
[15:32:48.274]   - Field: 'seed'
[15:32:48.275]   - Field: 'version'
[15:32:48.275]   - Field: 'result'
[15:32:48.275]   - Field: 'asynchronous'
[15:32:48.276]   - Field: 'calls'
[15:32:48.276]   - Field: 'globals'
[15:32:48.276]   - Field: 'stdout'
[15:32:48.277]   - Field: 'earlySignal'
[15:32:48.277]   - Field: 'lazy'
[15:32:48.277]   - Field: 'state'
[15:32:48.278] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:48.278] - Launch lazy future ...
[15:32:48.279] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:48.279] Packages needed by future strategies (n = 0): <none>
[15:32:48.280] {
[15:32:48.280]     {
[15:32:48.280]         {
[15:32:48.280]             ...future.startTime <- base::Sys.time()
[15:32:48.280]             {
[15:32:48.280]                 {
[15:32:48.280]                   {
[15:32:48.280]                     {
[15:32:48.280]                       {
[15:32:48.280]                         base::local({
[15:32:48.280]                           has_future <- base::requireNamespace("future", 
[15:32:48.280]                             quietly = TRUE)
[15:32:48.280]                           if (has_future) {
[15:32:48.280]                             ns <- base::getNamespace("future")
[15:32:48.280]                             version <- ns[[".package"]][["version"]]
[15:32:48.280]                             if (is.null(version)) 
[15:32:48.280]                               version <- utils::packageVersion("future")
[15:32:48.280]                           }
[15:32:48.280]                           else {
[15:32:48.280]                             version <- NULL
[15:32:48.280]                           }
[15:32:48.280]                           if (!has_future || version < "1.8.0") {
[15:32:48.280]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:48.280]                               "", base::R.version$version.string), 
[15:32:48.280]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:48.280]                                 base::R.version$platform, 8 * 
[15:32:48.280]                                   base::.Machine$sizeof.pointer), 
[15:32:48.280]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:48.280]                                 "release", "version")], collapse = " "), 
[15:32:48.280]                               hostname = base::Sys.info()[["nodename"]])
[15:32:48.280]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:48.280]                               info)
[15:32:48.280]                             info <- base::paste(info, collapse = "; ")
[15:32:48.280]                             if (!has_future) {
[15:32:48.280]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:48.280]                                 info)
[15:32:48.280]                             }
[15:32:48.280]                             else {
[15:32:48.280]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:48.280]                                 info, version)
[15:32:48.280]                             }
[15:32:48.280]                             base::stop(msg)
[15:32:48.280]                           }
[15:32:48.280]                         })
[15:32:48.280]                       }
[15:32:48.280]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:48.280]                       base::options(mc.cores = 1L)
[15:32:48.280]                     }
[15:32:48.280]                     base::local({
[15:32:48.280]                       for (pkg in "future.apply") {
[15:32:48.280]                         base::loadNamespace(pkg)
[15:32:48.280]                         base::library(pkg, character.only = TRUE)
[15:32:48.280]                       }
[15:32:48.280]                     })
[15:32:48.280]                   }
[15:32:48.280]                   ...future.strategy.old <- future::plan("list")
[15:32:48.280]                   options(future.plan = NULL)
[15:32:48.280]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.280]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:48.280]                 }
[15:32:48.280]                 ...future.workdir <- getwd()
[15:32:48.280]             }
[15:32:48.280]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:48.280]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:48.280]         }
[15:32:48.280]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:48.280]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:48.280]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:48.280]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:48.280]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:48.280]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:48.280]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:48.280]             base::names(...future.oldOptions))
[15:32:48.280]     }
[15:32:48.280]     if (FALSE) {
[15:32:48.280]     }
[15:32:48.280]     else {
[15:32:48.280]         if (TRUE) {
[15:32:48.280]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:48.280]                 open = "w")
[15:32:48.280]         }
[15:32:48.280]         else {
[15:32:48.280]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:48.280]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:48.280]         }
[15:32:48.280]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:48.280]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:48.280]             base::sink(type = "output", split = FALSE)
[15:32:48.280]             base::close(...future.stdout)
[15:32:48.280]         }, add = TRUE)
[15:32:48.280]     }
[15:32:48.280]     ...future.frame <- base::sys.nframe()
[15:32:48.280]     ...future.conditions <- base::list()
[15:32:48.280]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:48.280]     if (FALSE) {
[15:32:48.280]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:48.280]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:48.280]     }
[15:32:48.280]     ...future.result <- base::tryCatch({
[15:32:48.280]         base::withCallingHandlers({
[15:32:48.280]             ...future.value <- base::withVisible(base::local({
[15:32:48.280]                 ...future.makeSendCondition <- base::local({
[15:32:48.280]                   sendCondition <- NULL
[15:32:48.280]                   function(frame = 1L) {
[15:32:48.280]                     if (is.function(sendCondition)) 
[15:32:48.280]                       return(sendCondition)
[15:32:48.280]                     ns <- getNamespace("parallel")
[15:32:48.280]                     if (exists("sendData", mode = "function", 
[15:32:48.280]                       envir = ns)) {
[15:32:48.280]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:48.280]                         envir = ns)
[15:32:48.280]                       envir <- sys.frame(frame)
[15:32:48.280]                       master <- NULL
[15:32:48.280]                       while (!identical(envir, .GlobalEnv) && 
[15:32:48.280]                         !identical(envir, emptyenv())) {
[15:32:48.280]                         if (exists("master", mode = "list", envir = envir, 
[15:32:48.280]                           inherits = FALSE)) {
[15:32:48.280]                           master <- get("master", mode = "list", 
[15:32:48.280]                             envir = envir, inherits = FALSE)
[15:32:48.280]                           if (inherits(master, c("SOCKnode", 
[15:32:48.280]                             "SOCK0node"))) {
[15:32:48.280]                             sendCondition <<- function(cond) {
[15:32:48.280]                               data <- list(type = "VALUE", value = cond, 
[15:32:48.280]                                 success = TRUE)
[15:32:48.280]                               parallel_sendData(master, data)
[15:32:48.280]                             }
[15:32:48.280]                             return(sendCondition)
[15:32:48.280]                           }
[15:32:48.280]                         }
[15:32:48.280]                         frame <- frame + 1L
[15:32:48.280]                         envir <- sys.frame(frame)
[15:32:48.280]                       }
[15:32:48.280]                     }
[15:32:48.280]                     sendCondition <<- function(cond) NULL
[15:32:48.280]                   }
[15:32:48.280]                 })
[15:32:48.280]                 withCallingHandlers({
[15:32:48.280]                   {
[15:32:48.280]                     do.call(function(...) {
[15:32:48.280]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.280]                       if (!identical(...future.globals.maxSize.org, 
[15:32:48.280]                         ...future.globals.maxSize)) {
[15:32:48.280]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.280]                         on.exit(options(oopts), add = TRUE)
[15:32:48.280]                       }
[15:32:48.280]                       {
[15:32:48.280]                         lapply(seq_along(...future.elements_ii), 
[15:32:48.280]                           FUN = function(jj) {
[15:32:48.280]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.280]                             ...future.FUN(...future.X_jj, ...)
[15:32:48.280]                           })
[15:32:48.280]                       }
[15:32:48.280]                     }, args = future.call.arguments)
[15:32:48.280]                   }
[15:32:48.280]                 }, immediateCondition = function(cond) {
[15:32:48.280]                   sendCondition <- ...future.makeSendCondition()
[15:32:48.280]                   sendCondition(cond)
[15:32:48.280]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.280]                   {
[15:32:48.280]                     inherits <- base::inherits
[15:32:48.280]                     invokeRestart <- base::invokeRestart
[15:32:48.280]                     is.null <- base::is.null
[15:32:48.280]                     muffled <- FALSE
[15:32:48.280]                     if (inherits(cond, "message")) {
[15:32:48.280]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:48.280]                       if (muffled) 
[15:32:48.280]                         invokeRestart("muffleMessage")
[15:32:48.280]                     }
[15:32:48.280]                     else if (inherits(cond, "warning")) {
[15:32:48.280]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:48.280]                       if (muffled) 
[15:32:48.280]                         invokeRestart("muffleWarning")
[15:32:48.280]                     }
[15:32:48.280]                     else if (inherits(cond, "condition")) {
[15:32:48.280]                       if (!is.null(pattern)) {
[15:32:48.280]                         computeRestarts <- base::computeRestarts
[15:32:48.280]                         grepl <- base::grepl
[15:32:48.280]                         restarts <- computeRestarts(cond)
[15:32:48.280]                         for (restart in restarts) {
[15:32:48.280]                           name <- restart$name
[15:32:48.280]                           if (is.null(name)) 
[15:32:48.280]                             next
[15:32:48.280]                           if (!grepl(pattern, name)) 
[15:32:48.280]                             next
[15:32:48.280]                           invokeRestart(restart)
[15:32:48.280]                           muffled <- TRUE
[15:32:48.280]                           break
[15:32:48.280]                         }
[15:32:48.280]                       }
[15:32:48.280]                     }
[15:32:48.280]                     invisible(muffled)
[15:32:48.280]                   }
[15:32:48.280]                   muffleCondition(cond)
[15:32:48.280]                 })
[15:32:48.280]             }))
[15:32:48.280]             future::FutureResult(value = ...future.value$value, 
[15:32:48.280]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.280]                   ...future.rng), globalenv = if (FALSE) 
[15:32:48.280]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:48.280]                     ...future.globalenv.names))
[15:32:48.280]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:48.280]         }, condition = base::local({
[15:32:48.280]             c <- base::c
[15:32:48.280]             inherits <- base::inherits
[15:32:48.280]             invokeRestart <- base::invokeRestart
[15:32:48.280]             length <- base::length
[15:32:48.280]             list <- base::list
[15:32:48.280]             seq.int <- base::seq.int
[15:32:48.280]             signalCondition <- base::signalCondition
[15:32:48.280]             sys.calls <- base::sys.calls
[15:32:48.280]             `[[` <- base::`[[`
[15:32:48.280]             `+` <- base::`+`
[15:32:48.280]             `<<-` <- base::`<<-`
[15:32:48.280]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:48.280]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:48.280]                   3L)]
[15:32:48.280]             }
[15:32:48.280]             function(cond) {
[15:32:48.280]                 is_error <- inherits(cond, "error")
[15:32:48.280]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:48.280]                   NULL)
[15:32:48.280]                 if (is_error) {
[15:32:48.280]                   sessionInformation <- function() {
[15:32:48.280]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:48.280]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:48.280]                       search = base::search(), system = base::Sys.info())
[15:32:48.280]                   }
[15:32:48.280]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.280]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:48.280]                     cond$call), session = sessionInformation(), 
[15:32:48.280]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:48.280]                   signalCondition(cond)
[15:32:48.280]                 }
[15:32:48.280]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:48.280]                 "immediateCondition"))) {
[15:32:48.280]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:48.280]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.280]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:48.280]                   if (TRUE && !signal) {
[15:32:48.280]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.280]                     {
[15:32:48.280]                       inherits <- base::inherits
[15:32:48.280]                       invokeRestart <- base::invokeRestart
[15:32:48.280]                       is.null <- base::is.null
[15:32:48.280]                       muffled <- FALSE
[15:32:48.280]                       if (inherits(cond, "message")) {
[15:32:48.280]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.280]                         if (muffled) 
[15:32:48.280]                           invokeRestart("muffleMessage")
[15:32:48.280]                       }
[15:32:48.280]                       else if (inherits(cond, "warning")) {
[15:32:48.280]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.280]                         if (muffled) 
[15:32:48.280]                           invokeRestart("muffleWarning")
[15:32:48.280]                       }
[15:32:48.280]                       else if (inherits(cond, "condition")) {
[15:32:48.280]                         if (!is.null(pattern)) {
[15:32:48.280]                           computeRestarts <- base::computeRestarts
[15:32:48.280]                           grepl <- base::grepl
[15:32:48.280]                           restarts <- computeRestarts(cond)
[15:32:48.280]                           for (restart in restarts) {
[15:32:48.280]                             name <- restart$name
[15:32:48.280]                             if (is.null(name)) 
[15:32:48.280]                               next
[15:32:48.280]                             if (!grepl(pattern, name)) 
[15:32:48.280]                               next
[15:32:48.280]                             invokeRestart(restart)
[15:32:48.280]                             muffled <- TRUE
[15:32:48.280]                             break
[15:32:48.280]                           }
[15:32:48.280]                         }
[15:32:48.280]                       }
[15:32:48.280]                       invisible(muffled)
[15:32:48.280]                     }
[15:32:48.280]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.280]                   }
[15:32:48.280]                 }
[15:32:48.280]                 else {
[15:32:48.280]                   if (TRUE) {
[15:32:48.280]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.280]                     {
[15:32:48.280]                       inherits <- base::inherits
[15:32:48.280]                       invokeRestart <- base::invokeRestart
[15:32:48.280]                       is.null <- base::is.null
[15:32:48.280]                       muffled <- FALSE
[15:32:48.280]                       if (inherits(cond, "message")) {
[15:32:48.280]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.280]                         if (muffled) 
[15:32:48.280]                           invokeRestart("muffleMessage")
[15:32:48.280]                       }
[15:32:48.280]                       else if (inherits(cond, "warning")) {
[15:32:48.280]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.280]                         if (muffled) 
[15:32:48.280]                           invokeRestart("muffleWarning")
[15:32:48.280]                       }
[15:32:48.280]                       else if (inherits(cond, "condition")) {
[15:32:48.280]                         if (!is.null(pattern)) {
[15:32:48.280]                           computeRestarts <- base::computeRestarts
[15:32:48.280]                           grepl <- base::grepl
[15:32:48.280]                           restarts <- computeRestarts(cond)
[15:32:48.280]                           for (restart in restarts) {
[15:32:48.280]                             name <- restart$name
[15:32:48.280]                             if (is.null(name)) 
[15:32:48.280]                               next
[15:32:48.280]                             if (!grepl(pattern, name)) 
[15:32:48.280]                               next
[15:32:48.280]                             invokeRestart(restart)
[15:32:48.280]                             muffled <- TRUE
[15:32:48.280]                             break
[15:32:48.280]                           }
[15:32:48.280]                         }
[15:32:48.280]                       }
[15:32:48.280]                       invisible(muffled)
[15:32:48.280]                     }
[15:32:48.280]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.280]                   }
[15:32:48.280]                 }
[15:32:48.280]             }
[15:32:48.280]         }))
[15:32:48.280]     }, error = function(ex) {
[15:32:48.280]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:48.280]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.280]                 ...future.rng), started = ...future.startTime, 
[15:32:48.280]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:48.280]             version = "1.8"), class = "FutureResult")
[15:32:48.280]     }, finally = {
[15:32:48.280]         if (!identical(...future.workdir, getwd())) 
[15:32:48.280]             setwd(...future.workdir)
[15:32:48.280]         {
[15:32:48.280]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:48.280]                 ...future.oldOptions$nwarnings <- NULL
[15:32:48.280]             }
[15:32:48.280]             base::options(...future.oldOptions)
[15:32:48.280]             if (.Platform$OS.type == "windows") {
[15:32:48.280]                 old_names <- names(...future.oldEnvVars)
[15:32:48.280]                 envs <- base::Sys.getenv()
[15:32:48.280]                 names <- names(envs)
[15:32:48.280]                 common <- intersect(names, old_names)
[15:32:48.280]                 added <- setdiff(names, old_names)
[15:32:48.280]                 removed <- setdiff(old_names, names)
[15:32:48.280]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:48.280]                   envs[common]]
[15:32:48.280]                 NAMES <- toupper(changed)
[15:32:48.280]                 args <- list()
[15:32:48.280]                 for (kk in seq_along(NAMES)) {
[15:32:48.280]                   name <- changed[[kk]]
[15:32:48.280]                   NAME <- NAMES[[kk]]
[15:32:48.280]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.280]                     next
[15:32:48.280]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.280]                 }
[15:32:48.280]                 NAMES <- toupper(added)
[15:32:48.280]                 for (kk in seq_along(NAMES)) {
[15:32:48.280]                   name <- added[[kk]]
[15:32:48.280]                   NAME <- NAMES[[kk]]
[15:32:48.280]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.280]                     next
[15:32:48.280]                   args[[name]] <- ""
[15:32:48.280]                 }
[15:32:48.280]                 NAMES <- toupper(removed)
[15:32:48.280]                 for (kk in seq_along(NAMES)) {
[15:32:48.280]                   name <- removed[[kk]]
[15:32:48.280]                   NAME <- NAMES[[kk]]
[15:32:48.280]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.280]                     next
[15:32:48.280]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.280]                 }
[15:32:48.280]                 if (length(args) > 0) 
[15:32:48.280]                   base::do.call(base::Sys.setenv, args = args)
[15:32:48.280]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:48.280]             }
[15:32:48.280]             else {
[15:32:48.280]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:48.280]             }
[15:32:48.280]             {
[15:32:48.280]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:48.280]                   0L) {
[15:32:48.280]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:48.280]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:48.280]                   base::options(opts)
[15:32:48.280]                 }
[15:32:48.280]                 {
[15:32:48.280]                   {
[15:32:48.280]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:48.280]                     NULL
[15:32:48.280]                   }
[15:32:48.280]                   options(future.plan = NULL)
[15:32:48.280]                   if (is.na(NA_character_)) 
[15:32:48.280]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.280]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:48.280]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:48.280]                     .init = FALSE)
[15:32:48.280]                 }
[15:32:48.280]             }
[15:32:48.280]         }
[15:32:48.280]     })
[15:32:48.280]     if (TRUE) {
[15:32:48.280]         base::sink(type = "output", split = FALSE)
[15:32:48.280]         if (TRUE) {
[15:32:48.280]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:48.280]         }
[15:32:48.280]         else {
[15:32:48.280]             ...future.result["stdout"] <- base::list(NULL)
[15:32:48.280]         }
[15:32:48.280]         base::close(...future.stdout)
[15:32:48.280]         ...future.stdout <- NULL
[15:32:48.280]     }
[15:32:48.280]     ...future.result$conditions <- ...future.conditions
[15:32:48.280]     ...future.result$finished <- base::Sys.time()
[15:32:48.280]     ...future.result
[15:32:48.280] }
[15:32:48.292] Exporting 11 global objects (94.20 KiB) to cluster node #1 ...
[15:32:48.292] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:48.294] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:48.294] Exporting 'x_FUN' (2.12 KiB) to cluster node #1 ...
[15:32:48.295] Exporting 'x_FUN' (2.12 KiB) to cluster node #1 ... DONE
[15:32:48.296] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:48.297] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:48.297] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:48.298] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:48.298] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:48.299] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:48.299] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:48.300] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:48.300] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:48.301] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:48.302] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:48.302] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:48.303] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:48.303] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:48.304] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:48.304] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:48.304] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:48.305] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:48.306] Exporting 11 global objects (94.20 KiB) to cluster node #1 ... DONE
[15:32:48.307] MultisessionFuture started
[15:32:48.307] - Launch lazy future ... done
[15:32:48.308] run() for 'MultisessionFuture' ... done
[15:32:48.308] Created future:
[15:32:48.336] receiveMessageFromWorker() for ClusterFuture ...
[15:32:48.337] - Validating connection of MultisessionFuture
[15:32:48.337] - received message: FutureResult
[15:32:48.337] - Received FutureResult
[15:32:48.337] - Erased future from FutureRegistry
[15:32:48.338] result() for ClusterFuture ...
[15:32:48.338] - result already collected: FutureResult
[15:32:48.338] result() for ClusterFuture ... done
[15:32:48.338] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:48.308] MultisessionFuture:
[15:32:48.308] Label: 'future_vapply-1'
[15:32:48.308] Expression:
[15:32:48.308] {
[15:32:48.308]     do.call(function(...) {
[15:32:48.308]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.308]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.308]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.308]             on.exit(options(oopts), add = TRUE)
[15:32:48.308]         }
[15:32:48.308]         {
[15:32:48.308]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.308]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.308]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.308]             })
[15:32:48.308]         }
[15:32:48.308]     }, args = future.call.arguments)
[15:32:48.308] }
[15:32:48.308] Lazy evaluation: FALSE
[15:32:48.308] Asynchronous evaluation: TRUE
[15:32:48.308] Local evaluation: TRUE
[15:32:48.308] Environment: R_GlobalEnv
[15:32:48.308] Capture standard output: TRUE
[15:32:48.308] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:48.308] Globals: 11 objects totaling 94.47 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 2.12 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:48.308] Packages: 1 packages ('future.apply')
[15:32:48.308] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:48.308] Resolved: TRUE
[15:32:48.308] Value: <not collected>
[15:32:48.308] Conditions captured: <none>
[15:32:48.308] Early signaling: FALSE
[15:32:48.308] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:48.308] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.339] Chunk #1 of 2 ... DONE
[15:32:48.339] Chunk #2 of 2 ...
[15:32:48.339]  - Finding globals in 'X' for chunk #2 ...
[15:32:48.339] getGlobalsAndPackages() ...
[15:32:48.339] Searching for globals...
[15:32:48.340] 
[15:32:48.340] Searching for globals ... DONE
[15:32:48.340] - globals: [0] <none>
[15:32:48.340] getGlobalsAndPackages() ... DONE
[15:32:48.340]    + additional globals found: [n=0] 
[15:32:48.341]    + additional namespaces needed: [n=0] 
[15:32:48.341]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:48.341]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:48.341]  - seeds: <none>
[15:32:48.341]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.341] getGlobalsAndPackages() ...
[15:32:48.342] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.342] Resolving globals: FALSE
[15:32:48.342] Tweak future expression to call with '...' arguments ...
[15:32:48.342] {
[15:32:48.342]     do.call(function(...) {
[15:32:48.342]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.342]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.342]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.342]             on.exit(options(oopts), add = TRUE)
[15:32:48.342]         }
[15:32:48.342]         {
[15:32:48.342]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.342]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.342]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.342]             })
[15:32:48.342]         }
[15:32:48.342]     }, args = future.call.arguments)
[15:32:48.342] }
[15:32:48.343] Tweak future expression to call with '...' arguments ... DONE
[15:32:48.343] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.344] - packages: [1] 'future.apply'
[15:32:48.344] getGlobalsAndPackages() ... DONE
[15:32:48.344] run() for 'Future' ...
[15:32:48.345] - state: 'created'
[15:32:48.345] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:48.360] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.360] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:48.360]   - Field: 'node'
[15:32:48.360]   - Field: 'label'
[15:32:48.360]   - Field: 'local'
[15:32:48.361]   - Field: 'owner'
[15:32:48.361]   - Field: 'envir'
[15:32:48.361]   - Field: 'workers'
[15:32:48.361]   - Field: 'packages'
[15:32:48.361]   - Field: 'gc'
[15:32:48.361]   - Field: 'conditions'
[15:32:48.362]   - Field: 'persistent'
[15:32:48.362]   - Field: 'expr'
[15:32:48.362]   - Field: 'uuid'
[15:32:48.362]   - Field: 'seed'
[15:32:48.362]   - Field: 'version'
[15:32:48.363]   - Field: 'result'
[15:32:48.363]   - Field: 'asynchronous'
[15:32:48.363]   - Field: 'calls'
[15:32:48.363]   - Field: 'globals'
[15:32:48.363]   - Field: 'stdout'
[15:32:48.363]   - Field: 'earlySignal'
[15:32:48.364]   - Field: 'lazy'
[15:32:48.364]   - Field: 'state'
[15:32:48.364] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:48.364] - Launch lazy future ...
[15:32:48.365] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:48.365] Packages needed by future strategies (n = 0): <none>
[15:32:48.365] {
[15:32:48.365]     {
[15:32:48.365]         {
[15:32:48.365]             ...future.startTime <- base::Sys.time()
[15:32:48.365]             {
[15:32:48.365]                 {
[15:32:48.365]                   {
[15:32:48.365]                     {
[15:32:48.365]                       {
[15:32:48.365]                         base::local({
[15:32:48.365]                           has_future <- base::requireNamespace("future", 
[15:32:48.365]                             quietly = TRUE)
[15:32:48.365]                           if (has_future) {
[15:32:48.365]                             ns <- base::getNamespace("future")
[15:32:48.365]                             version <- ns[[".package"]][["version"]]
[15:32:48.365]                             if (is.null(version)) 
[15:32:48.365]                               version <- utils::packageVersion("future")
[15:32:48.365]                           }
[15:32:48.365]                           else {
[15:32:48.365]                             version <- NULL
[15:32:48.365]                           }
[15:32:48.365]                           if (!has_future || version < "1.8.0") {
[15:32:48.365]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:48.365]                               "", base::R.version$version.string), 
[15:32:48.365]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:48.365]                                 base::R.version$platform, 8 * 
[15:32:48.365]                                   base::.Machine$sizeof.pointer), 
[15:32:48.365]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:48.365]                                 "release", "version")], collapse = " "), 
[15:32:48.365]                               hostname = base::Sys.info()[["nodename"]])
[15:32:48.365]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:48.365]                               info)
[15:32:48.365]                             info <- base::paste(info, collapse = "; ")
[15:32:48.365]                             if (!has_future) {
[15:32:48.365]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:48.365]                                 info)
[15:32:48.365]                             }
[15:32:48.365]                             else {
[15:32:48.365]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:48.365]                                 info, version)
[15:32:48.365]                             }
[15:32:48.365]                             base::stop(msg)
[15:32:48.365]                           }
[15:32:48.365]                         })
[15:32:48.365]                       }
[15:32:48.365]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:48.365]                       base::options(mc.cores = 1L)
[15:32:48.365]                     }
[15:32:48.365]                     base::local({
[15:32:48.365]                       for (pkg in "future.apply") {
[15:32:48.365]                         base::loadNamespace(pkg)
[15:32:48.365]                         base::library(pkg, character.only = TRUE)
[15:32:48.365]                       }
[15:32:48.365]                     })
[15:32:48.365]                   }
[15:32:48.365]                   ...future.strategy.old <- future::plan("list")
[15:32:48.365]                   options(future.plan = NULL)
[15:32:48.365]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.365]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:48.365]                 }
[15:32:48.365]                 ...future.workdir <- getwd()
[15:32:48.365]             }
[15:32:48.365]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:48.365]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:48.365]         }
[15:32:48.365]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:48.365]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:48.365]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:48.365]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:48.365]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:48.365]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:48.365]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:48.365]             base::names(...future.oldOptions))
[15:32:48.365]     }
[15:32:48.365]     if (FALSE) {
[15:32:48.365]     }
[15:32:48.365]     else {
[15:32:48.365]         if (TRUE) {
[15:32:48.365]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:48.365]                 open = "w")
[15:32:48.365]         }
[15:32:48.365]         else {
[15:32:48.365]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:48.365]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:48.365]         }
[15:32:48.365]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:48.365]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:48.365]             base::sink(type = "output", split = FALSE)
[15:32:48.365]             base::close(...future.stdout)
[15:32:48.365]         }, add = TRUE)
[15:32:48.365]     }
[15:32:48.365]     ...future.frame <- base::sys.nframe()
[15:32:48.365]     ...future.conditions <- base::list()
[15:32:48.365]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:48.365]     if (FALSE) {
[15:32:48.365]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:48.365]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:48.365]     }
[15:32:48.365]     ...future.result <- base::tryCatch({
[15:32:48.365]         base::withCallingHandlers({
[15:32:48.365]             ...future.value <- base::withVisible(base::local({
[15:32:48.365]                 ...future.makeSendCondition <- base::local({
[15:32:48.365]                   sendCondition <- NULL
[15:32:48.365]                   function(frame = 1L) {
[15:32:48.365]                     if (is.function(sendCondition)) 
[15:32:48.365]                       return(sendCondition)
[15:32:48.365]                     ns <- getNamespace("parallel")
[15:32:48.365]                     if (exists("sendData", mode = "function", 
[15:32:48.365]                       envir = ns)) {
[15:32:48.365]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:48.365]                         envir = ns)
[15:32:48.365]                       envir <- sys.frame(frame)
[15:32:48.365]                       master <- NULL
[15:32:48.365]                       while (!identical(envir, .GlobalEnv) && 
[15:32:48.365]                         !identical(envir, emptyenv())) {
[15:32:48.365]                         if (exists("master", mode = "list", envir = envir, 
[15:32:48.365]                           inherits = FALSE)) {
[15:32:48.365]                           master <- get("master", mode = "list", 
[15:32:48.365]                             envir = envir, inherits = FALSE)
[15:32:48.365]                           if (inherits(master, c("SOCKnode", 
[15:32:48.365]                             "SOCK0node"))) {
[15:32:48.365]                             sendCondition <<- function(cond) {
[15:32:48.365]                               data <- list(type = "VALUE", value = cond, 
[15:32:48.365]                                 success = TRUE)
[15:32:48.365]                               parallel_sendData(master, data)
[15:32:48.365]                             }
[15:32:48.365]                             return(sendCondition)
[15:32:48.365]                           }
[15:32:48.365]                         }
[15:32:48.365]                         frame <- frame + 1L
[15:32:48.365]                         envir <- sys.frame(frame)
[15:32:48.365]                       }
[15:32:48.365]                     }
[15:32:48.365]                     sendCondition <<- function(cond) NULL
[15:32:48.365]                   }
[15:32:48.365]                 })
[15:32:48.365]                 withCallingHandlers({
[15:32:48.365]                   {
[15:32:48.365]                     do.call(function(...) {
[15:32:48.365]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.365]                       if (!identical(...future.globals.maxSize.org, 
[15:32:48.365]                         ...future.globals.maxSize)) {
[15:32:48.365]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.365]                         on.exit(options(oopts), add = TRUE)
[15:32:48.365]                       }
[15:32:48.365]                       {
[15:32:48.365]                         lapply(seq_along(...future.elements_ii), 
[15:32:48.365]                           FUN = function(jj) {
[15:32:48.365]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.365]                             ...future.FUN(...future.X_jj, ...)
[15:32:48.365]                           })
[15:32:48.365]                       }
[15:32:48.365]                     }, args = future.call.arguments)
[15:32:48.365]                   }
[15:32:48.365]                 }, immediateCondition = function(cond) {
[15:32:48.365]                   sendCondition <- ...future.makeSendCondition()
[15:32:48.365]                   sendCondition(cond)
[15:32:48.365]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.365]                   {
[15:32:48.365]                     inherits <- base::inherits
[15:32:48.365]                     invokeRestart <- base::invokeRestart
[15:32:48.365]                     is.null <- base::is.null
[15:32:48.365]                     muffled <- FALSE
[15:32:48.365]                     if (inherits(cond, "message")) {
[15:32:48.365]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:48.365]                       if (muffled) 
[15:32:48.365]                         invokeRestart("muffleMessage")
[15:32:48.365]                     }
[15:32:48.365]                     else if (inherits(cond, "warning")) {
[15:32:48.365]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:48.365]                       if (muffled) 
[15:32:48.365]                         invokeRestart("muffleWarning")
[15:32:48.365]                     }
[15:32:48.365]                     else if (inherits(cond, "condition")) {
[15:32:48.365]                       if (!is.null(pattern)) {
[15:32:48.365]                         computeRestarts <- base::computeRestarts
[15:32:48.365]                         grepl <- base::grepl
[15:32:48.365]                         restarts <- computeRestarts(cond)
[15:32:48.365]                         for (restart in restarts) {
[15:32:48.365]                           name <- restart$name
[15:32:48.365]                           if (is.null(name)) 
[15:32:48.365]                             next
[15:32:48.365]                           if (!grepl(pattern, name)) 
[15:32:48.365]                             next
[15:32:48.365]                           invokeRestart(restart)
[15:32:48.365]                           muffled <- TRUE
[15:32:48.365]                           break
[15:32:48.365]                         }
[15:32:48.365]                       }
[15:32:48.365]                     }
[15:32:48.365]                     invisible(muffled)
[15:32:48.365]                   }
[15:32:48.365]                   muffleCondition(cond)
[15:32:48.365]                 })
[15:32:48.365]             }))
[15:32:48.365]             future::FutureResult(value = ...future.value$value, 
[15:32:48.365]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.365]                   ...future.rng), globalenv = if (FALSE) 
[15:32:48.365]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:48.365]                     ...future.globalenv.names))
[15:32:48.365]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:48.365]         }, condition = base::local({
[15:32:48.365]             c <- base::c
[15:32:48.365]             inherits <- base::inherits
[15:32:48.365]             invokeRestart <- base::invokeRestart
[15:32:48.365]             length <- base::length
[15:32:48.365]             list <- base::list
[15:32:48.365]             seq.int <- base::seq.int
[15:32:48.365]             signalCondition <- base::signalCondition
[15:32:48.365]             sys.calls <- base::sys.calls
[15:32:48.365]             `[[` <- base::`[[`
[15:32:48.365]             `+` <- base::`+`
[15:32:48.365]             `<<-` <- base::`<<-`
[15:32:48.365]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:48.365]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:48.365]                   3L)]
[15:32:48.365]             }
[15:32:48.365]             function(cond) {
[15:32:48.365]                 is_error <- inherits(cond, "error")
[15:32:48.365]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:48.365]                   NULL)
[15:32:48.365]                 if (is_error) {
[15:32:48.365]                   sessionInformation <- function() {
[15:32:48.365]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:48.365]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:48.365]                       search = base::search(), system = base::Sys.info())
[15:32:48.365]                   }
[15:32:48.365]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.365]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:48.365]                     cond$call), session = sessionInformation(), 
[15:32:48.365]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:48.365]                   signalCondition(cond)
[15:32:48.365]                 }
[15:32:48.365]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:48.365]                 "immediateCondition"))) {
[15:32:48.365]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:48.365]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.365]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:48.365]                   if (TRUE && !signal) {
[15:32:48.365]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.365]                     {
[15:32:48.365]                       inherits <- base::inherits
[15:32:48.365]                       invokeRestart <- base::invokeRestart
[15:32:48.365]                       is.null <- base::is.null
[15:32:48.365]                       muffled <- FALSE
[15:32:48.365]                       if (inherits(cond, "message")) {
[15:32:48.365]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.365]                         if (muffled) 
[15:32:48.365]                           invokeRestart("muffleMessage")
[15:32:48.365]                       }
[15:32:48.365]                       else if (inherits(cond, "warning")) {
[15:32:48.365]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.365]                         if (muffled) 
[15:32:48.365]                           invokeRestart("muffleWarning")
[15:32:48.365]                       }
[15:32:48.365]                       else if (inherits(cond, "condition")) {
[15:32:48.365]                         if (!is.null(pattern)) {
[15:32:48.365]                           computeRestarts <- base::computeRestarts
[15:32:48.365]                           grepl <- base::grepl
[15:32:48.365]                           restarts <- computeRestarts(cond)
[15:32:48.365]                           for (restart in restarts) {
[15:32:48.365]                             name <- restart$name
[15:32:48.365]                             if (is.null(name)) 
[15:32:48.365]                               next
[15:32:48.365]                             if (!grepl(pattern, name)) 
[15:32:48.365]                               next
[15:32:48.365]                             invokeRestart(restart)
[15:32:48.365]                             muffled <- TRUE
[15:32:48.365]                             break
[15:32:48.365]                           }
[15:32:48.365]                         }
[15:32:48.365]                       }
[15:32:48.365]                       invisible(muffled)
[15:32:48.365]                     }
[15:32:48.365]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.365]                   }
[15:32:48.365]                 }
[15:32:48.365]                 else {
[15:32:48.365]                   if (TRUE) {
[15:32:48.365]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.365]                     {
[15:32:48.365]                       inherits <- base::inherits
[15:32:48.365]                       invokeRestart <- base::invokeRestart
[15:32:48.365]                       is.null <- base::is.null
[15:32:48.365]                       muffled <- FALSE
[15:32:48.365]                       if (inherits(cond, "message")) {
[15:32:48.365]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.365]                         if (muffled) 
[15:32:48.365]                           invokeRestart("muffleMessage")
[15:32:48.365]                       }
[15:32:48.365]                       else if (inherits(cond, "warning")) {
[15:32:48.365]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.365]                         if (muffled) 
[15:32:48.365]                           invokeRestart("muffleWarning")
[15:32:48.365]                       }
[15:32:48.365]                       else if (inherits(cond, "condition")) {
[15:32:48.365]                         if (!is.null(pattern)) {
[15:32:48.365]                           computeRestarts <- base::computeRestarts
[15:32:48.365]                           grepl <- base::grepl
[15:32:48.365]                           restarts <- computeRestarts(cond)
[15:32:48.365]                           for (restart in restarts) {
[15:32:48.365]                             name <- restart$name
[15:32:48.365]                             if (is.null(name)) 
[15:32:48.365]                               next
[15:32:48.365]                             if (!grepl(pattern, name)) 
[15:32:48.365]                               next
[15:32:48.365]                             invokeRestart(restart)
[15:32:48.365]                             muffled <- TRUE
[15:32:48.365]                             break
[15:32:48.365]                           }
[15:32:48.365]                         }
[15:32:48.365]                       }
[15:32:48.365]                       invisible(muffled)
[15:32:48.365]                     }
[15:32:48.365]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.365]                   }
[15:32:48.365]                 }
[15:32:48.365]             }
[15:32:48.365]         }))
[15:32:48.365]     }, error = function(ex) {
[15:32:48.365]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:48.365]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.365]                 ...future.rng), started = ...future.startTime, 
[15:32:48.365]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:48.365]             version = "1.8"), class = "FutureResult")
[15:32:48.365]     }, finally = {
[15:32:48.365]         if (!identical(...future.workdir, getwd())) 
[15:32:48.365]             setwd(...future.workdir)
[15:32:48.365]         {
[15:32:48.365]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:48.365]                 ...future.oldOptions$nwarnings <- NULL
[15:32:48.365]             }
[15:32:48.365]             base::options(...future.oldOptions)
[15:32:48.365]             if (.Platform$OS.type == "windows") {
[15:32:48.365]                 old_names <- names(...future.oldEnvVars)
[15:32:48.365]                 envs <- base::Sys.getenv()
[15:32:48.365]                 names <- names(envs)
[15:32:48.365]                 common <- intersect(names, old_names)
[15:32:48.365]                 added <- setdiff(names, old_names)
[15:32:48.365]                 removed <- setdiff(old_names, names)
[15:32:48.365]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:48.365]                   envs[common]]
[15:32:48.365]                 NAMES <- toupper(changed)
[15:32:48.365]                 args <- list()
[15:32:48.365]                 for (kk in seq_along(NAMES)) {
[15:32:48.365]                   name <- changed[[kk]]
[15:32:48.365]                   NAME <- NAMES[[kk]]
[15:32:48.365]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.365]                     next
[15:32:48.365]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.365]                 }
[15:32:48.365]                 NAMES <- toupper(added)
[15:32:48.365]                 for (kk in seq_along(NAMES)) {
[15:32:48.365]                   name <- added[[kk]]
[15:32:48.365]                   NAME <- NAMES[[kk]]
[15:32:48.365]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.365]                     next
[15:32:48.365]                   args[[name]] <- ""
[15:32:48.365]                 }
[15:32:48.365]                 NAMES <- toupper(removed)
[15:32:48.365]                 for (kk in seq_along(NAMES)) {
[15:32:48.365]                   name <- removed[[kk]]
[15:32:48.365]                   NAME <- NAMES[[kk]]
[15:32:48.365]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.365]                     next
[15:32:48.365]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.365]                 }
[15:32:48.365]                 if (length(args) > 0) 
[15:32:48.365]                   base::do.call(base::Sys.setenv, args = args)
[15:32:48.365]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:48.365]             }
[15:32:48.365]             else {
[15:32:48.365]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:48.365]             }
[15:32:48.365]             {
[15:32:48.365]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:48.365]                   0L) {
[15:32:48.365]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:48.365]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:48.365]                   base::options(opts)
[15:32:48.365]                 }
[15:32:48.365]                 {
[15:32:48.365]                   {
[15:32:48.365]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:48.365]                     NULL
[15:32:48.365]                   }
[15:32:48.365]                   options(future.plan = NULL)
[15:32:48.365]                   if (is.na(NA_character_)) 
[15:32:48.365]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.365]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:48.365]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:48.365]                     .init = FALSE)
[15:32:48.365]                 }
[15:32:48.365]             }
[15:32:48.365]         }
[15:32:48.365]     })
[15:32:48.365]     if (TRUE) {
[15:32:48.365]         base::sink(type = "output", split = FALSE)
[15:32:48.365]         if (TRUE) {
[15:32:48.365]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:48.365]         }
[15:32:48.365]         else {
[15:32:48.365]             ...future.result["stdout"] <- base::list(NULL)
[15:32:48.365]         }
[15:32:48.365]         base::close(...future.stdout)
[15:32:48.365]         ...future.stdout <- NULL
[15:32:48.365]     }
[15:32:48.365]     ...future.result$conditions <- ...future.conditions
[15:32:48.365]     ...future.result$finished <- base::Sys.time()
[15:32:48.365]     ...future.result
[15:32:48.365] }
[15:32:48.371] Exporting 11 global objects (94.20 KiB) to cluster node #1 ...
[15:32:48.371] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:48.372] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:48.372] Exporting 'x_FUN' (2.12 KiB) to cluster node #1 ...
[15:32:48.373] Exporting 'x_FUN' (2.12 KiB) to cluster node #1 ... DONE
[15:32:48.373] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:48.373] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:48.374] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:48.374] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:48.374] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:48.375] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:48.375] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:48.376] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:48.376] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:48.376] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:48.377] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:48.377] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:48.377] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:48.378] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:48.378] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:48.378] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:48.379] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:48.379] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:48.379] Exporting 11 global objects (94.20 KiB) to cluster node #1 ... DONE
[15:32:48.380] MultisessionFuture started
[15:32:48.380] - Launch lazy future ... done
[15:32:48.380] run() for 'MultisessionFuture' ... done
[15:32:48.381] Created future:
[15:32:48.397] receiveMessageFromWorker() for ClusterFuture ...
[15:32:48.397] - Validating connection of MultisessionFuture
[15:32:48.398] - received message: FutureResult
[15:32:48.398] - Received FutureResult
[15:32:48.398] - Erased future from FutureRegistry
[15:32:48.398] result() for ClusterFuture ...
[15:32:48.398] - result already collected: FutureResult
[15:32:48.399] result() for ClusterFuture ... done
[15:32:48.399] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:48.381] MultisessionFuture:
[15:32:48.381] Label: 'future_vapply-2'
[15:32:48.381] Expression:
[15:32:48.381] {
[15:32:48.381]     do.call(function(...) {
[15:32:48.381]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.381]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.381]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.381]             on.exit(options(oopts), add = TRUE)
[15:32:48.381]         }
[15:32:48.381]         {
[15:32:48.381]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.381]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.381]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.381]             })
[15:32:48.381]         }
[15:32:48.381]     }, args = future.call.arguments)
[15:32:48.381] }
[15:32:48.381] Lazy evaluation: FALSE
[15:32:48.381] Asynchronous evaluation: TRUE
[15:32:48.381] Local evaluation: TRUE
[15:32:48.381] Environment: R_GlobalEnv
[15:32:48.381] Capture standard output: TRUE
[15:32:48.381] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:48.381] Globals: 11 objects totaling 94.47 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 2.12 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:48.381] Packages: 1 packages ('future.apply')
[15:32:48.381] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:48.381] Resolved: TRUE
[15:32:48.381] Value: <not collected>
[15:32:48.381] Conditions captured: <none>
[15:32:48.381] Early signaling: FALSE
[15:32:48.381] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:48.381] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.399] Chunk #2 of 2 ... DONE
[15:32:48.399] Launching 2 futures (chunks) ... DONE
[15:32:48.400] Resolving 2 futures (chunks) ...
[15:32:48.400] resolve() on list ...
[15:32:48.400]  recursive: 0
[15:32:48.400]  length: 2
[15:32:48.400] 
[15:32:48.401] Future #1
[15:32:48.401] result() for ClusterFuture ...
[15:32:48.401] - result already collected: FutureResult
[15:32:48.401] result() for ClusterFuture ... done
[15:32:48.401] result() for ClusterFuture ...
[15:32:48.401] - result already collected: FutureResult
[15:32:48.401] result() for ClusterFuture ... done
[15:32:48.402] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:48.402] - nx: 2
[15:32:48.402] - relay: TRUE
[15:32:48.402] - stdout: TRUE
[15:32:48.402] - signal: TRUE
[15:32:48.402] - resignal: FALSE
[15:32:48.403] - force: TRUE
[15:32:48.403] - relayed: [n=2] FALSE, FALSE
[15:32:48.403] - queued futures: [n=2] FALSE, FALSE
[15:32:48.403]  - until=1
[15:32:48.403]  - relaying element #1
[15:32:48.403] result() for ClusterFuture ...
[15:32:48.404] - result already collected: FutureResult
[15:32:48.404] result() for ClusterFuture ... done
[15:32:48.404] result() for ClusterFuture ...
[15:32:48.404] - result already collected: FutureResult
[15:32:48.404] result() for ClusterFuture ... done
[15:32:48.405] result() for ClusterFuture ...
[15:32:48.405] - result already collected: FutureResult
[15:32:48.405] result() for ClusterFuture ... done
[15:32:48.405] result() for ClusterFuture ...
[15:32:48.405] - result already collected: FutureResult
[15:32:48.405] result() for ClusterFuture ... done
[15:32:48.405] - relayed: [n=2] TRUE, FALSE
[15:32:48.406] - queued futures: [n=2] TRUE, FALSE
[15:32:48.406] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:48.406]  length: 1 (resolved future 1)
[15:32:48.407] Future #2
[15:32:48.407] result() for ClusterFuture ...
[15:32:48.407] - result already collected: FutureResult
[15:32:48.407] result() for ClusterFuture ... done
[15:32:48.408] result() for ClusterFuture ...
[15:32:48.408] - result already collected: FutureResult
[15:32:48.408] result() for ClusterFuture ... done
[15:32:48.409] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:48.409] - nx: 2
[15:32:48.409] - relay: TRUE
[15:32:48.410] - stdout: TRUE
[15:32:48.410] - signal: TRUE
[15:32:48.410] - resignal: FALSE
[15:32:48.410] - force: TRUE
[15:32:48.411] - relayed: [n=2] TRUE, FALSE
[15:32:48.411] - queued futures: [n=2] TRUE, FALSE
[15:32:48.411]  - until=2
[15:32:48.412]  - relaying element #2
[15:32:48.412] result() for ClusterFuture ...
[15:32:48.412] - result already collected: FutureResult
[15:32:48.412] result() for ClusterFuture ... done
[15:32:48.413] result() for ClusterFuture ...
[15:32:48.413] - result already collected: FutureResult
[15:32:48.413] result() for ClusterFuture ... done
[15:32:48.414] result() for ClusterFuture ...
[15:32:48.414] - result already collected: FutureResult
[15:32:48.414] result() for ClusterFuture ... done
[15:32:48.415] result() for ClusterFuture ...
[15:32:48.415] - result already collected: FutureResult
[15:32:48.415] result() for ClusterFuture ... done
[15:32:48.415] - relayed: [n=2] TRUE, TRUE
[15:32:48.416] - queued futures: [n=2] TRUE, TRUE
[15:32:48.416] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:48.416]  length: 0 (resolved future 2)
[15:32:48.417] Relaying remaining futures
[15:32:48.417] signalConditionsASAP(NULL, pos=0) ...
[15:32:48.417] - nx: 2
[15:32:48.418] - relay: TRUE
[15:32:48.418] - stdout: TRUE
[15:32:48.418] - signal: TRUE
[15:32:48.418] - resignal: FALSE
[15:32:48.419] - force: TRUE
[15:32:48.419] - relayed: [n=2] TRUE, TRUE
[15:32:48.419] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:48.420] - relayed: [n=2] TRUE, TRUE
[15:32:48.420] - queued futures: [n=2] TRUE, TRUE
[15:32:48.420] signalConditionsASAP(NULL, pos=0) ... done
[15:32:48.421] resolve() on list ... DONE
[15:32:48.421] result() for ClusterFuture ...
[15:32:48.421] - result already collected: FutureResult
[15:32:48.421] result() for ClusterFuture ... done
[15:32:48.422] result() for ClusterFuture ...
[15:32:48.422] - result already collected: FutureResult
[15:32:48.422] result() for ClusterFuture ... done
[15:32:48.423] result() for ClusterFuture ...
[15:32:48.423] - result already collected: FutureResult
[15:32:48.423] result() for ClusterFuture ... done
[15:32:48.423] result() for ClusterFuture ...
[15:32:48.424] - result already collected: FutureResult
[15:32:48.424] result() for ClusterFuture ... done
[15:32:48.424]  - Number of value chunks collected: 2
[15:32:48.425] Resolving 2 futures (chunks) ... DONE
[15:32:48.425] Reducing values from 2 chunks ...
[15:32:48.425]  - Number of values collected after concatenation: 10
[15:32:48.426]  - Number of values expected: 10
[15:32:48.426] Reducing values from 2 chunks ... DONE
[15:32:48.426] future_lapply() ... DONE
 num [1:2, 1:10] 1 1 2 4 3 9 4 16 5 25 ...
 int [1:2, 1:2, 1:10] 1 1 1 1 2 2 2 2 3 3 ...
[15:32:48.428] future_lapply() ...
[15:32:48.436] Number of chunks: 2
[15:32:48.437] getGlobalsAndPackagesXApply() ...
[15:32:48.437]  - future.globals: TRUE
[15:32:48.437] getGlobalsAndPackages() ...
[15:32:48.438] Searching for globals...
[15:32:48.445] - globals found: [17] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'matrix'
[15:32:48.446] Searching for globals ... DONE
[15:32:48.446] Resolving globals: FALSE
[15:32:48.448] The total size of the 7 globals is 94.95 KiB (97232 bytes)
[15:32:48.449] The total size of the 7 globals exported for future expression ('FUN()') is 94.95 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:48.449] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:48.449] - packages: [1] 'future.apply'
[15:32:48.450] getGlobalsAndPackages() ... DONE
[15:32:48.450]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:48.450]  - needed namespaces: [n=1] 'future.apply'
[15:32:48.451] Finding globals ... DONE
[15:32:48.451]  - use_args: TRUE
[15:32:48.451]  - Getting '...' globals ...
[15:32:48.452] resolve() on list ...
[15:32:48.452]  recursive: 0
[15:32:48.453]  length: 1
[15:32:48.453]  elements: '...'
[15:32:48.453]  length: 0 (resolved future 1)
[15:32:48.454] resolve() on list ... DONE
[15:32:48.454]    - '...' content: [n=0] 
[15:32:48.454] List of 1
[15:32:48.454]  $ ...: list()
[15:32:48.454]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:48.454]  - attr(*, "where")=List of 1
[15:32:48.454]   ..$ ...:<environment: 0x0000022d418b5958> 
[15:32:48.454]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:48.454]  - attr(*, "resolved")= logi TRUE
[15:32:48.454]  - attr(*, "total_size")= num NA
[15:32:48.459]  - Getting '...' globals ... DONE
[15:32:48.460] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:48.460] List of 8
[15:32:48.460]  $ ...future.FUN:function (x, ...)  
[15:32:48.460]  $ x_FUN        :function (x)  
[15:32:48.460]  $ times        : int 4
[15:32:48.460]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:48.460]  $ stop_if_not  :function (...)  
[15:32:48.460]  $ dim          : int [1:2] 2 2
[15:32:48.460]  $ valid_types  : chr [1:2] "logical" "integer"
[15:32:48.460]  $ ...          : list()
[15:32:48.460]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:48.460]  - attr(*, "where")=List of 8
[15:32:48.460]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:48.460]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:48.460]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:48.460]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:48.460]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:48.460]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:48.460]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:48.460]   ..$ ...          :<environment: 0x0000022d418b5958> 
[15:32:48.460]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:48.460]  - attr(*, "resolved")= logi FALSE
[15:32:48.460]  - attr(*, "total_size")= num 97232
[15:32:48.474] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:48.474] getGlobalsAndPackagesXApply() ... DONE
[15:32:48.474] Number of futures (= number of chunks): 2
[15:32:48.475] Launching 2 futures (chunks) ...
[15:32:48.475] Chunk #1 of 2 ...
[15:32:48.475]  - Finding globals in 'X' for chunk #1 ...
[15:32:48.476] getGlobalsAndPackages() ...
[15:32:48.476] Searching for globals...
[15:32:48.476] 
[15:32:48.477] Searching for globals ... DONE
[15:32:48.477] - globals: [0] <none>
[15:32:48.477] getGlobalsAndPackages() ... DONE
[15:32:48.477]    + additional globals found: [n=0] 
[15:32:48.478]    + additional namespaces needed: [n=0] 
[15:32:48.478]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:48.478]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:48.479]  - seeds: <none>
[15:32:48.479]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.479] getGlobalsAndPackages() ...
[15:32:48.479] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.480] Resolving globals: FALSE
[15:32:48.480] Tweak future expression to call with '...' arguments ...
[15:32:48.480] {
[15:32:48.480]     do.call(function(...) {
[15:32:48.480]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.480]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.480]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.480]             on.exit(options(oopts), add = TRUE)
[15:32:48.480]         }
[15:32:48.480]         {
[15:32:48.480]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.480]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.480]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.480]             })
[15:32:48.480]         }
[15:32:48.480]     }, args = future.call.arguments)
[15:32:48.480] }
[15:32:48.481] Tweak future expression to call with '...' arguments ... DONE
[15:32:48.482] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.482] - packages: [1] 'future.apply'
[15:32:48.483] getGlobalsAndPackages() ... DONE
[15:32:48.483] run() for 'Future' ...
[15:32:48.484] - state: 'created'
[15:32:48.484] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:48.503] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.503] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:48.503]   - Field: 'node'
[15:32:48.503]   - Field: 'label'
[15:32:48.504]   - Field: 'local'
[15:32:48.504]   - Field: 'owner'
[15:32:48.504]   - Field: 'envir'
[15:32:48.504]   - Field: 'workers'
[15:32:48.504]   - Field: 'packages'
[15:32:48.505]   - Field: 'gc'
[15:32:48.505]   - Field: 'conditions'
[15:32:48.505]   - Field: 'persistent'
[15:32:48.505]   - Field: 'expr'
[15:32:48.505]   - Field: 'uuid'
[15:32:48.505]   - Field: 'seed'
[15:32:48.506]   - Field: 'version'
[15:32:48.506]   - Field: 'result'
[15:32:48.506]   - Field: 'asynchronous'
[15:32:48.506]   - Field: 'calls'
[15:32:48.507]   - Field: 'globals'
[15:32:48.507]   - Field: 'stdout'
[15:32:48.507]   - Field: 'earlySignal'
[15:32:48.507]   - Field: 'lazy'
[15:32:48.507]   - Field: 'state'
[15:32:48.507] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:48.508] - Launch lazy future ...
[15:32:48.508] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:48.508] Packages needed by future strategies (n = 0): <none>
[15:32:48.509] {
[15:32:48.509]     {
[15:32:48.509]         {
[15:32:48.509]             ...future.startTime <- base::Sys.time()
[15:32:48.509]             {
[15:32:48.509]                 {
[15:32:48.509]                   {
[15:32:48.509]                     {
[15:32:48.509]                       {
[15:32:48.509]                         base::local({
[15:32:48.509]                           has_future <- base::requireNamespace("future", 
[15:32:48.509]                             quietly = TRUE)
[15:32:48.509]                           if (has_future) {
[15:32:48.509]                             ns <- base::getNamespace("future")
[15:32:48.509]                             version <- ns[[".package"]][["version"]]
[15:32:48.509]                             if (is.null(version)) 
[15:32:48.509]                               version <- utils::packageVersion("future")
[15:32:48.509]                           }
[15:32:48.509]                           else {
[15:32:48.509]                             version <- NULL
[15:32:48.509]                           }
[15:32:48.509]                           if (!has_future || version < "1.8.0") {
[15:32:48.509]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:48.509]                               "", base::R.version$version.string), 
[15:32:48.509]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:48.509]                                 base::R.version$platform, 8 * 
[15:32:48.509]                                   base::.Machine$sizeof.pointer), 
[15:32:48.509]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:48.509]                                 "release", "version")], collapse = " "), 
[15:32:48.509]                               hostname = base::Sys.info()[["nodename"]])
[15:32:48.509]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:48.509]                               info)
[15:32:48.509]                             info <- base::paste(info, collapse = "; ")
[15:32:48.509]                             if (!has_future) {
[15:32:48.509]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:48.509]                                 info)
[15:32:48.509]                             }
[15:32:48.509]                             else {
[15:32:48.509]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:48.509]                                 info, version)
[15:32:48.509]                             }
[15:32:48.509]                             base::stop(msg)
[15:32:48.509]                           }
[15:32:48.509]                         })
[15:32:48.509]                       }
[15:32:48.509]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:48.509]                       base::options(mc.cores = 1L)
[15:32:48.509]                     }
[15:32:48.509]                     base::local({
[15:32:48.509]                       for (pkg in "future.apply") {
[15:32:48.509]                         base::loadNamespace(pkg)
[15:32:48.509]                         base::library(pkg, character.only = TRUE)
[15:32:48.509]                       }
[15:32:48.509]                     })
[15:32:48.509]                   }
[15:32:48.509]                   ...future.strategy.old <- future::plan("list")
[15:32:48.509]                   options(future.plan = NULL)
[15:32:48.509]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.509]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:48.509]                 }
[15:32:48.509]                 ...future.workdir <- getwd()
[15:32:48.509]             }
[15:32:48.509]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:48.509]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:48.509]         }
[15:32:48.509]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:48.509]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:48.509]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:48.509]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:48.509]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:48.509]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:48.509]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:48.509]             base::names(...future.oldOptions))
[15:32:48.509]     }
[15:32:48.509]     if (FALSE) {
[15:32:48.509]     }
[15:32:48.509]     else {
[15:32:48.509]         if (TRUE) {
[15:32:48.509]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:48.509]                 open = "w")
[15:32:48.509]         }
[15:32:48.509]         else {
[15:32:48.509]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:48.509]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:48.509]         }
[15:32:48.509]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:48.509]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:48.509]             base::sink(type = "output", split = FALSE)
[15:32:48.509]             base::close(...future.stdout)
[15:32:48.509]         }, add = TRUE)
[15:32:48.509]     }
[15:32:48.509]     ...future.frame <- base::sys.nframe()
[15:32:48.509]     ...future.conditions <- base::list()
[15:32:48.509]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:48.509]     if (FALSE) {
[15:32:48.509]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:48.509]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:48.509]     }
[15:32:48.509]     ...future.result <- base::tryCatch({
[15:32:48.509]         base::withCallingHandlers({
[15:32:48.509]             ...future.value <- base::withVisible(base::local({
[15:32:48.509]                 ...future.makeSendCondition <- base::local({
[15:32:48.509]                   sendCondition <- NULL
[15:32:48.509]                   function(frame = 1L) {
[15:32:48.509]                     if (is.function(sendCondition)) 
[15:32:48.509]                       return(sendCondition)
[15:32:48.509]                     ns <- getNamespace("parallel")
[15:32:48.509]                     if (exists("sendData", mode = "function", 
[15:32:48.509]                       envir = ns)) {
[15:32:48.509]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:48.509]                         envir = ns)
[15:32:48.509]                       envir <- sys.frame(frame)
[15:32:48.509]                       master <- NULL
[15:32:48.509]                       while (!identical(envir, .GlobalEnv) && 
[15:32:48.509]                         !identical(envir, emptyenv())) {
[15:32:48.509]                         if (exists("master", mode = "list", envir = envir, 
[15:32:48.509]                           inherits = FALSE)) {
[15:32:48.509]                           master <- get("master", mode = "list", 
[15:32:48.509]                             envir = envir, inherits = FALSE)
[15:32:48.509]                           if (inherits(master, c("SOCKnode", 
[15:32:48.509]                             "SOCK0node"))) {
[15:32:48.509]                             sendCondition <<- function(cond) {
[15:32:48.509]                               data <- list(type = "VALUE", value = cond, 
[15:32:48.509]                                 success = TRUE)
[15:32:48.509]                               parallel_sendData(master, data)
[15:32:48.509]                             }
[15:32:48.509]                             return(sendCondition)
[15:32:48.509]                           }
[15:32:48.509]                         }
[15:32:48.509]                         frame <- frame + 1L
[15:32:48.509]                         envir <- sys.frame(frame)
[15:32:48.509]                       }
[15:32:48.509]                     }
[15:32:48.509]                     sendCondition <<- function(cond) NULL
[15:32:48.509]                   }
[15:32:48.509]                 })
[15:32:48.509]                 withCallingHandlers({
[15:32:48.509]                   {
[15:32:48.509]                     do.call(function(...) {
[15:32:48.509]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.509]                       if (!identical(...future.globals.maxSize.org, 
[15:32:48.509]                         ...future.globals.maxSize)) {
[15:32:48.509]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.509]                         on.exit(options(oopts), add = TRUE)
[15:32:48.509]                       }
[15:32:48.509]                       {
[15:32:48.509]                         lapply(seq_along(...future.elements_ii), 
[15:32:48.509]                           FUN = function(jj) {
[15:32:48.509]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.509]                             ...future.FUN(...future.X_jj, ...)
[15:32:48.509]                           })
[15:32:48.509]                       }
[15:32:48.509]                     }, args = future.call.arguments)
[15:32:48.509]                   }
[15:32:48.509]                 }, immediateCondition = function(cond) {
[15:32:48.509]                   sendCondition <- ...future.makeSendCondition()
[15:32:48.509]                   sendCondition(cond)
[15:32:48.509]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.509]                   {
[15:32:48.509]                     inherits <- base::inherits
[15:32:48.509]                     invokeRestart <- base::invokeRestart
[15:32:48.509]                     is.null <- base::is.null
[15:32:48.509]                     muffled <- FALSE
[15:32:48.509]                     if (inherits(cond, "message")) {
[15:32:48.509]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:48.509]                       if (muffled) 
[15:32:48.509]                         invokeRestart("muffleMessage")
[15:32:48.509]                     }
[15:32:48.509]                     else if (inherits(cond, "warning")) {
[15:32:48.509]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:48.509]                       if (muffled) 
[15:32:48.509]                         invokeRestart("muffleWarning")
[15:32:48.509]                     }
[15:32:48.509]                     else if (inherits(cond, "condition")) {
[15:32:48.509]                       if (!is.null(pattern)) {
[15:32:48.509]                         computeRestarts <- base::computeRestarts
[15:32:48.509]                         grepl <- base::grepl
[15:32:48.509]                         restarts <- computeRestarts(cond)
[15:32:48.509]                         for (restart in restarts) {
[15:32:48.509]                           name <- restart$name
[15:32:48.509]                           if (is.null(name)) 
[15:32:48.509]                             next
[15:32:48.509]                           if (!grepl(pattern, name)) 
[15:32:48.509]                             next
[15:32:48.509]                           invokeRestart(restart)
[15:32:48.509]                           muffled <- TRUE
[15:32:48.509]                           break
[15:32:48.509]                         }
[15:32:48.509]                       }
[15:32:48.509]                     }
[15:32:48.509]                     invisible(muffled)
[15:32:48.509]                   }
[15:32:48.509]                   muffleCondition(cond)
[15:32:48.509]                 })
[15:32:48.509]             }))
[15:32:48.509]             future::FutureResult(value = ...future.value$value, 
[15:32:48.509]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.509]                   ...future.rng), globalenv = if (FALSE) 
[15:32:48.509]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:48.509]                     ...future.globalenv.names))
[15:32:48.509]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:48.509]         }, condition = base::local({
[15:32:48.509]             c <- base::c
[15:32:48.509]             inherits <- base::inherits
[15:32:48.509]             invokeRestart <- base::invokeRestart
[15:32:48.509]             length <- base::length
[15:32:48.509]             list <- base::list
[15:32:48.509]             seq.int <- base::seq.int
[15:32:48.509]             signalCondition <- base::signalCondition
[15:32:48.509]             sys.calls <- base::sys.calls
[15:32:48.509]             `[[` <- base::`[[`
[15:32:48.509]             `+` <- base::`+`
[15:32:48.509]             `<<-` <- base::`<<-`
[15:32:48.509]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:48.509]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:48.509]                   3L)]
[15:32:48.509]             }
[15:32:48.509]             function(cond) {
[15:32:48.509]                 is_error <- inherits(cond, "error")
[15:32:48.509]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:48.509]                   NULL)
[15:32:48.509]                 if (is_error) {
[15:32:48.509]                   sessionInformation <- function() {
[15:32:48.509]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:48.509]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:48.509]                       search = base::search(), system = base::Sys.info())
[15:32:48.509]                   }
[15:32:48.509]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.509]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:48.509]                     cond$call), session = sessionInformation(), 
[15:32:48.509]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:48.509]                   signalCondition(cond)
[15:32:48.509]                 }
[15:32:48.509]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:48.509]                 "immediateCondition"))) {
[15:32:48.509]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:48.509]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.509]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:48.509]                   if (TRUE && !signal) {
[15:32:48.509]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.509]                     {
[15:32:48.509]                       inherits <- base::inherits
[15:32:48.509]                       invokeRestart <- base::invokeRestart
[15:32:48.509]                       is.null <- base::is.null
[15:32:48.509]                       muffled <- FALSE
[15:32:48.509]                       if (inherits(cond, "message")) {
[15:32:48.509]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.509]                         if (muffled) 
[15:32:48.509]                           invokeRestart("muffleMessage")
[15:32:48.509]                       }
[15:32:48.509]                       else if (inherits(cond, "warning")) {
[15:32:48.509]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.509]                         if (muffled) 
[15:32:48.509]                           invokeRestart("muffleWarning")
[15:32:48.509]                       }
[15:32:48.509]                       else if (inherits(cond, "condition")) {
[15:32:48.509]                         if (!is.null(pattern)) {
[15:32:48.509]                           computeRestarts <- base::computeRestarts
[15:32:48.509]                           grepl <- base::grepl
[15:32:48.509]                           restarts <- computeRestarts(cond)
[15:32:48.509]                           for (restart in restarts) {
[15:32:48.509]                             name <- restart$name
[15:32:48.509]                             if (is.null(name)) 
[15:32:48.509]                               next
[15:32:48.509]                             if (!grepl(pattern, name)) 
[15:32:48.509]                               next
[15:32:48.509]                             invokeRestart(restart)
[15:32:48.509]                             muffled <- TRUE
[15:32:48.509]                             break
[15:32:48.509]                           }
[15:32:48.509]                         }
[15:32:48.509]                       }
[15:32:48.509]                       invisible(muffled)
[15:32:48.509]                     }
[15:32:48.509]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.509]                   }
[15:32:48.509]                 }
[15:32:48.509]                 else {
[15:32:48.509]                   if (TRUE) {
[15:32:48.509]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.509]                     {
[15:32:48.509]                       inherits <- base::inherits
[15:32:48.509]                       invokeRestart <- base::invokeRestart
[15:32:48.509]                       is.null <- base::is.null
[15:32:48.509]                       muffled <- FALSE
[15:32:48.509]                       if (inherits(cond, "message")) {
[15:32:48.509]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.509]                         if (muffled) 
[15:32:48.509]                           invokeRestart("muffleMessage")
[15:32:48.509]                       }
[15:32:48.509]                       else if (inherits(cond, "warning")) {
[15:32:48.509]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.509]                         if (muffled) 
[15:32:48.509]                           invokeRestart("muffleWarning")
[15:32:48.509]                       }
[15:32:48.509]                       else if (inherits(cond, "condition")) {
[15:32:48.509]                         if (!is.null(pattern)) {
[15:32:48.509]                           computeRestarts <- base::computeRestarts
[15:32:48.509]                           grepl <- base::grepl
[15:32:48.509]                           restarts <- computeRestarts(cond)
[15:32:48.509]                           for (restart in restarts) {
[15:32:48.509]                             name <- restart$name
[15:32:48.509]                             if (is.null(name)) 
[15:32:48.509]                               next
[15:32:48.509]                             if (!grepl(pattern, name)) 
[15:32:48.509]                               next
[15:32:48.509]                             invokeRestart(restart)
[15:32:48.509]                             muffled <- TRUE
[15:32:48.509]                             break
[15:32:48.509]                           }
[15:32:48.509]                         }
[15:32:48.509]                       }
[15:32:48.509]                       invisible(muffled)
[15:32:48.509]                     }
[15:32:48.509]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.509]                   }
[15:32:48.509]                 }
[15:32:48.509]             }
[15:32:48.509]         }))
[15:32:48.509]     }, error = function(ex) {
[15:32:48.509]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:48.509]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.509]                 ...future.rng), started = ...future.startTime, 
[15:32:48.509]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:48.509]             version = "1.8"), class = "FutureResult")
[15:32:48.509]     }, finally = {
[15:32:48.509]         if (!identical(...future.workdir, getwd())) 
[15:32:48.509]             setwd(...future.workdir)
[15:32:48.509]         {
[15:32:48.509]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:48.509]                 ...future.oldOptions$nwarnings <- NULL
[15:32:48.509]             }
[15:32:48.509]             base::options(...future.oldOptions)
[15:32:48.509]             if (.Platform$OS.type == "windows") {
[15:32:48.509]                 old_names <- names(...future.oldEnvVars)
[15:32:48.509]                 envs <- base::Sys.getenv()
[15:32:48.509]                 names <- names(envs)
[15:32:48.509]                 common <- intersect(names, old_names)
[15:32:48.509]                 added <- setdiff(names, old_names)
[15:32:48.509]                 removed <- setdiff(old_names, names)
[15:32:48.509]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:48.509]                   envs[common]]
[15:32:48.509]                 NAMES <- toupper(changed)
[15:32:48.509]                 args <- list()
[15:32:48.509]                 for (kk in seq_along(NAMES)) {
[15:32:48.509]                   name <- changed[[kk]]
[15:32:48.509]                   NAME <- NAMES[[kk]]
[15:32:48.509]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.509]                     next
[15:32:48.509]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.509]                 }
[15:32:48.509]                 NAMES <- toupper(added)
[15:32:48.509]                 for (kk in seq_along(NAMES)) {
[15:32:48.509]                   name <- added[[kk]]
[15:32:48.509]                   NAME <- NAMES[[kk]]
[15:32:48.509]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.509]                     next
[15:32:48.509]                   args[[name]] <- ""
[15:32:48.509]                 }
[15:32:48.509]                 NAMES <- toupper(removed)
[15:32:48.509]                 for (kk in seq_along(NAMES)) {
[15:32:48.509]                   name <- removed[[kk]]
[15:32:48.509]                   NAME <- NAMES[[kk]]
[15:32:48.509]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.509]                     next
[15:32:48.509]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.509]                 }
[15:32:48.509]                 if (length(args) > 0) 
[15:32:48.509]                   base::do.call(base::Sys.setenv, args = args)
[15:32:48.509]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:48.509]             }
[15:32:48.509]             else {
[15:32:48.509]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:48.509]             }
[15:32:48.509]             {
[15:32:48.509]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:48.509]                   0L) {
[15:32:48.509]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:48.509]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:48.509]                   base::options(opts)
[15:32:48.509]                 }
[15:32:48.509]                 {
[15:32:48.509]                   {
[15:32:48.509]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:48.509]                     NULL
[15:32:48.509]                   }
[15:32:48.509]                   options(future.plan = NULL)
[15:32:48.509]                   if (is.na(NA_character_)) 
[15:32:48.509]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.509]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:48.509]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:48.509]                     .init = FALSE)
[15:32:48.509]                 }
[15:32:48.509]             }
[15:32:48.509]         }
[15:32:48.509]     })
[15:32:48.509]     if (TRUE) {
[15:32:48.509]         base::sink(type = "output", split = FALSE)
[15:32:48.509]         if (TRUE) {
[15:32:48.509]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:48.509]         }
[15:32:48.509]         else {
[15:32:48.509]             ...future.result["stdout"] <- base::list(NULL)
[15:32:48.509]         }
[15:32:48.509]         base::close(...future.stdout)
[15:32:48.509]         ...future.stdout <- NULL
[15:32:48.509]     }
[15:32:48.509]     ...future.result$conditions <- ...future.conditions
[15:32:48.509]     ...future.result$finished <- base::Sys.time()
[15:32:48.509]     ...future.result
[15:32:48.509] }
[15:32:48.516] Exporting 11 global objects (94.95 KiB) to cluster node #1 ...
[15:32:48.517] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:48.517] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:48.518] Exporting 'x_FUN' (2.90 KiB) to cluster node #1 ...
[15:32:48.518] Exporting 'x_FUN' (2.90 KiB) to cluster node #1 ... DONE
[15:32:48.519] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:48.519] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:48.520] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:48.521] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:48.521] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:48.522] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:48.522] Exporting 'dim' (56 bytes) to cluster node #1 ...
[15:32:48.523] Exporting 'dim' (56 bytes) to cluster node #1 ... DONE
[15:32:48.523] Exporting 'valid_types' (176 bytes) to cluster node #1 ...
[15:32:48.524] Exporting 'valid_types' (176 bytes) to cluster node #1 ... DONE
[15:32:48.524] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:48.525] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:48.525] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:48.526] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:48.527] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:48.527] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:48.528] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:48.528] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:48.529] Exporting 11 global objects (94.95 KiB) to cluster node #1 ... DONE
[15:32:48.530] MultisessionFuture started
[15:32:48.530] - Launch lazy future ... done
[15:32:48.530] run() for 'MultisessionFuture' ... done
[15:32:48.531] Created future:
[15:32:48.560] receiveMessageFromWorker() for ClusterFuture ...
[15:32:48.560] - Validating connection of MultisessionFuture
[15:32:48.561] - received message: FutureResult
[15:32:48.561] - Received FutureResult
[15:32:48.561] - Erased future from FutureRegistry
[15:32:48.562] result() for ClusterFuture ...
[15:32:48.562] - result already collected: FutureResult
[15:32:48.562] result() for ClusterFuture ... done
[15:32:48.563] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:48.531] MultisessionFuture:
[15:32:48.531] Label: 'future_vapply-1'
[15:32:48.531] Expression:
[15:32:48.531] {
[15:32:48.531]     do.call(function(...) {
[15:32:48.531]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.531]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.531]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.531]             on.exit(options(oopts), add = TRUE)
[15:32:48.531]         }
[15:32:48.531]         {
[15:32:48.531]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.531]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.531]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.531]             })
[15:32:48.531]         }
[15:32:48.531]     }, args = future.call.arguments)
[15:32:48.531] }
[15:32:48.531] Lazy evaluation: FALSE
[15:32:48.531] Asynchronous evaluation: TRUE
[15:32:48.531] Local evaluation: TRUE
[15:32:48.531] Environment: R_GlobalEnv
[15:32:48.531] Capture standard output: TRUE
[15:32:48.531] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:48.531] Globals: 11 objects totaling 95.23 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 2.90 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:48.531] Packages: 1 packages ('future.apply')
[15:32:48.531] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:48.531] Resolved: TRUE
[15:32:48.531] Value: <not collected>
[15:32:48.531] Conditions captured: <none>
[15:32:48.531] Early signaling: FALSE
[15:32:48.531] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:48.531] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.563] Chunk #1 of 2 ... DONE
[15:32:48.564] Chunk #2 of 2 ...
[15:32:48.564]  - Finding globals in 'X' for chunk #2 ...
[15:32:48.564] getGlobalsAndPackages() ...
[15:32:48.565] Searching for globals...
[15:32:48.565] 
[15:32:48.566] Searching for globals ... DONE
[15:32:48.566] - globals: [0] <none>
[15:32:48.566] getGlobalsAndPackages() ... DONE
[15:32:48.566]    + additional globals found: [n=0] 
[15:32:48.567]    + additional namespaces needed: [n=0] 
[15:32:48.567]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:48.567]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:48.568]  - seeds: <none>
[15:32:48.568]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.568] getGlobalsAndPackages() ...
[15:32:48.569] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.569] Resolving globals: FALSE
[15:32:48.569] Tweak future expression to call with '...' arguments ...
[15:32:48.570] {
[15:32:48.570]     do.call(function(...) {
[15:32:48.570]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.570]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.570]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.570]             on.exit(options(oopts), add = TRUE)
[15:32:48.570]         }
[15:32:48.570]         {
[15:32:48.570]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.570]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.570]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.570]             })
[15:32:48.570]         }
[15:32:48.570]     }, args = future.call.arguments)
[15:32:48.570] }
[15:32:48.570] Tweak future expression to call with '...' arguments ... DONE
[15:32:48.572] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.572] - packages: [1] 'future.apply'
[15:32:48.572] getGlobalsAndPackages() ... DONE
[15:32:48.573] run() for 'Future' ...
[15:32:48.573] - state: 'created'
[15:32:48.574] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:48.592] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.593] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:48.593]   - Field: 'node'
[15:32:48.594]   - Field: 'label'
[15:32:48.594]   - Field: 'local'
[15:32:48.594]   - Field: 'owner'
[15:32:48.595]   - Field: 'envir'
[15:32:48.595]   - Field: 'workers'
[15:32:48.595]   - Field: 'packages'
[15:32:48.596]   - Field: 'gc'
[15:32:48.596]   - Field: 'conditions'
[15:32:48.596]   - Field: 'persistent'
[15:32:48.597]   - Field: 'expr'
[15:32:48.597]   - Field: 'uuid'
[15:32:48.597]   - Field: 'seed'
[15:32:48.598]   - Field: 'version'
[15:32:48.598]   - Field: 'result'
[15:32:48.598]   - Field: 'asynchronous'
[15:32:48.599]   - Field: 'calls'
[15:32:48.599]   - Field: 'globals'
[15:32:48.599]   - Field: 'stdout'
[15:32:48.599]   - Field: 'earlySignal'
[15:32:48.600]   - Field: 'lazy'
[15:32:48.600]   - Field: 'state'
[15:32:48.600] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:48.601] - Launch lazy future ...
[15:32:48.601] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:48.602] Packages needed by future strategies (n = 0): <none>
[15:32:48.603] {
[15:32:48.603]     {
[15:32:48.603]         {
[15:32:48.603]             ...future.startTime <- base::Sys.time()
[15:32:48.603]             {
[15:32:48.603]                 {
[15:32:48.603]                   {
[15:32:48.603]                     {
[15:32:48.603]                       {
[15:32:48.603]                         base::local({
[15:32:48.603]                           has_future <- base::requireNamespace("future", 
[15:32:48.603]                             quietly = TRUE)
[15:32:48.603]                           if (has_future) {
[15:32:48.603]                             ns <- base::getNamespace("future")
[15:32:48.603]                             version <- ns[[".package"]][["version"]]
[15:32:48.603]                             if (is.null(version)) 
[15:32:48.603]                               version <- utils::packageVersion("future")
[15:32:48.603]                           }
[15:32:48.603]                           else {
[15:32:48.603]                             version <- NULL
[15:32:48.603]                           }
[15:32:48.603]                           if (!has_future || version < "1.8.0") {
[15:32:48.603]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:48.603]                               "", base::R.version$version.string), 
[15:32:48.603]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:48.603]                                 base::R.version$platform, 8 * 
[15:32:48.603]                                   base::.Machine$sizeof.pointer), 
[15:32:48.603]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:48.603]                                 "release", "version")], collapse = " "), 
[15:32:48.603]                               hostname = base::Sys.info()[["nodename"]])
[15:32:48.603]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:48.603]                               info)
[15:32:48.603]                             info <- base::paste(info, collapse = "; ")
[15:32:48.603]                             if (!has_future) {
[15:32:48.603]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:48.603]                                 info)
[15:32:48.603]                             }
[15:32:48.603]                             else {
[15:32:48.603]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:48.603]                                 info, version)
[15:32:48.603]                             }
[15:32:48.603]                             base::stop(msg)
[15:32:48.603]                           }
[15:32:48.603]                         })
[15:32:48.603]                       }
[15:32:48.603]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:48.603]                       base::options(mc.cores = 1L)
[15:32:48.603]                     }
[15:32:48.603]                     base::local({
[15:32:48.603]                       for (pkg in "future.apply") {
[15:32:48.603]                         base::loadNamespace(pkg)
[15:32:48.603]                         base::library(pkg, character.only = TRUE)
[15:32:48.603]                       }
[15:32:48.603]                     })
[15:32:48.603]                   }
[15:32:48.603]                   ...future.strategy.old <- future::plan("list")
[15:32:48.603]                   options(future.plan = NULL)
[15:32:48.603]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.603]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:48.603]                 }
[15:32:48.603]                 ...future.workdir <- getwd()
[15:32:48.603]             }
[15:32:48.603]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:48.603]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:48.603]         }
[15:32:48.603]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:48.603]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:48.603]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:48.603]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:48.603]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:48.603]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:48.603]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:48.603]             base::names(...future.oldOptions))
[15:32:48.603]     }
[15:32:48.603]     if (FALSE) {
[15:32:48.603]     }
[15:32:48.603]     else {
[15:32:48.603]         if (TRUE) {
[15:32:48.603]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:48.603]                 open = "w")
[15:32:48.603]         }
[15:32:48.603]         else {
[15:32:48.603]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:48.603]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:48.603]         }
[15:32:48.603]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:48.603]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:48.603]             base::sink(type = "output", split = FALSE)
[15:32:48.603]             base::close(...future.stdout)
[15:32:48.603]         }, add = TRUE)
[15:32:48.603]     }
[15:32:48.603]     ...future.frame <- base::sys.nframe()
[15:32:48.603]     ...future.conditions <- base::list()
[15:32:48.603]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:48.603]     if (FALSE) {
[15:32:48.603]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:48.603]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:48.603]     }
[15:32:48.603]     ...future.result <- base::tryCatch({
[15:32:48.603]         base::withCallingHandlers({
[15:32:48.603]             ...future.value <- base::withVisible(base::local({
[15:32:48.603]                 ...future.makeSendCondition <- base::local({
[15:32:48.603]                   sendCondition <- NULL
[15:32:48.603]                   function(frame = 1L) {
[15:32:48.603]                     if (is.function(sendCondition)) 
[15:32:48.603]                       return(sendCondition)
[15:32:48.603]                     ns <- getNamespace("parallel")
[15:32:48.603]                     if (exists("sendData", mode = "function", 
[15:32:48.603]                       envir = ns)) {
[15:32:48.603]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:48.603]                         envir = ns)
[15:32:48.603]                       envir <- sys.frame(frame)
[15:32:48.603]                       master <- NULL
[15:32:48.603]                       while (!identical(envir, .GlobalEnv) && 
[15:32:48.603]                         !identical(envir, emptyenv())) {
[15:32:48.603]                         if (exists("master", mode = "list", envir = envir, 
[15:32:48.603]                           inherits = FALSE)) {
[15:32:48.603]                           master <- get("master", mode = "list", 
[15:32:48.603]                             envir = envir, inherits = FALSE)
[15:32:48.603]                           if (inherits(master, c("SOCKnode", 
[15:32:48.603]                             "SOCK0node"))) {
[15:32:48.603]                             sendCondition <<- function(cond) {
[15:32:48.603]                               data <- list(type = "VALUE", value = cond, 
[15:32:48.603]                                 success = TRUE)
[15:32:48.603]                               parallel_sendData(master, data)
[15:32:48.603]                             }
[15:32:48.603]                             return(sendCondition)
[15:32:48.603]                           }
[15:32:48.603]                         }
[15:32:48.603]                         frame <- frame + 1L
[15:32:48.603]                         envir <- sys.frame(frame)
[15:32:48.603]                       }
[15:32:48.603]                     }
[15:32:48.603]                     sendCondition <<- function(cond) NULL
[15:32:48.603]                   }
[15:32:48.603]                 })
[15:32:48.603]                 withCallingHandlers({
[15:32:48.603]                   {
[15:32:48.603]                     do.call(function(...) {
[15:32:48.603]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.603]                       if (!identical(...future.globals.maxSize.org, 
[15:32:48.603]                         ...future.globals.maxSize)) {
[15:32:48.603]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.603]                         on.exit(options(oopts), add = TRUE)
[15:32:48.603]                       }
[15:32:48.603]                       {
[15:32:48.603]                         lapply(seq_along(...future.elements_ii), 
[15:32:48.603]                           FUN = function(jj) {
[15:32:48.603]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.603]                             ...future.FUN(...future.X_jj, ...)
[15:32:48.603]                           })
[15:32:48.603]                       }
[15:32:48.603]                     }, args = future.call.arguments)
[15:32:48.603]                   }
[15:32:48.603]                 }, immediateCondition = function(cond) {
[15:32:48.603]                   sendCondition <- ...future.makeSendCondition()
[15:32:48.603]                   sendCondition(cond)
[15:32:48.603]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.603]                   {
[15:32:48.603]                     inherits <- base::inherits
[15:32:48.603]                     invokeRestart <- base::invokeRestart
[15:32:48.603]                     is.null <- base::is.null
[15:32:48.603]                     muffled <- FALSE
[15:32:48.603]                     if (inherits(cond, "message")) {
[15:32:48.603]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:48.603]                       if (muffled) 
[15:32:48.603]                         invokeRestart("muffleMessage")
[15:32:48.603]                     }
[15:32:48.603]                     else if (inherits(cond, "warning")) {
[15:32:48.603]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:48.603]                       if (muffled) 
[15:32:48.603]                         invokeRestart("muffleWarning")
[15:32:48.603]                     }
[15:32:48.603]                     else if (inherits(cond, "condition")) {
[15:32:48.603]                       if (!is.null(pattern)) {
[15:32:48.603]                         computeRestarts <- base::computeRestarts
[15:32:48.603]                         grepl <- base::grepl
[15:32:48.603]                         restarts <- computeRestarts(cond)
[15:32:48.603]                         for (restart in restarts) {
[15:32:48.603]                           name <- restart$name
[15:32:48.603]                           if (is.null(name)) 
[15:32:48.603]                             next
[15:32:48.603]                           if (!grepl(pattern, name)) 
[15:32:48.603]                             next
[15:32:48.603]                           invokeRestart(restart)
[15:32:48.603]                           muffled <- TRUE
[15:32:48.603]                           break
[15:32:48.603]                         }
[15:32:48.603]                       }
[15:32:48.603]                     }
[15:32:48.603]                     invisible(muffled)
[15:32:48.603]                   }
[15:32:48.603]                   muffleCondition(cond)
[15:32:48.603]                 })
[15:32:48.603]             }))
[15:32:48.603]             future::FutureResult(value = ...future.value$value, 
[15:32:48.603]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.603]                   ...future.rng), globalenv = if (FALSE) 
[15:32:48.603]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:48.603]                     ...future.globalenv.names))
[15:32:48.603]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:48.603]         }, condition = base::local({
[15:32:48.603]             c <- base::c
[15:32:48.603]             inherits <- base::inherits
[15:32:48.603]             invokeRestart <- base::invokeRestart
[15:32:48.603]             length <- base::length
[15:32:48.603]             list <- base::list
[15:32:48.603]             seq.int <- base::seq.int
[15:32:48.603]             signalCondition <- base::signalCondition
[15:32:48.603]             sys.calls <- base::sys.calls
[15:32:48.603]             `[[` <- base::`[[`
[15:32:48.603]             `+` <- base::`+`
[15:32:48.603]             `<<-` <- base::`<<-`
[15:32:48.603]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:48.603]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:48.603]                   3L)]
[15:32:48.603]             }
[15:32:48.603]             function(cond) {
[15:32:48.603]                 is_error <- inherits(cond, "error")
[15:32:48.603]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:48.603]                   NULL)
[15:32:48.603]                 if (is_error) {
[15:32:48.603]                   sessionInformation <- function() {
[15:32:48.603]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:48.603]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:48.603]                       search = base::search(), system = base::Sys.info())
[15:32:48.603]                   }
[15:32:48.603]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.603]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:48.603]                     cond$call), session = sessionInformation(), 
[15:32:48.603]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:48.603]                   signalCondition(cond)
[15:32:48.603]                 }
[15:32:48.603]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:48.603]                 "immediateCondition"))) {
[15:32:48.603]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:48.603]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.603]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:48.603]                   if (TRUE && !signal) {
[15:32:48.603]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.603]                     {
[15:32:48.603]                       inherits <- base::inherits
[15:32:48.603]                       invokeRestart <- base::invokeRestart
[15:32:48.603]                       is.null <- base::is.null
[15:32:48.603]                       muffled <- FALSE
[15:32:48.603]                       if (inherits(cond, "message")) {
[15:32:48.603]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.603]                         if (muffled) 
[15:32:48.603]                           invokeRestart("muffleMessage")
[15:32:48.603]                       }
[15:32:48.603]                       else if (inherits(cond, "warning")) {
[15:32:48.603]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.603]                         if (muffled) 
[15:32:48.603]                           invokeRestart("muffleWarning")
[15:32:48.603]                       }
[15:32:48.603]                       else if (inherits(cond, "condition")) {
[15:32:48.603]                         if (!is.null(pattern)) {
[15:32:48.603]                           computeRestarts <- base::computeRestarts
[15:32:48.603]                           grepl <- base::grepl
[15:32:48.603]                           restarts <- computeRestarts(cond)
[15:32:48.603]                           for (restart in restarts) {
[15:32:48.603]                             name <- restart$name
[15:32:48.603]                             if (is.null(name)) 
[15:32:48.603]                               next
[15:32:48.603]                             if (!grepl(pattern, name)) 
[15:32:48.603]                               next
[15:32:48.603]                             invokeRestart(restart)
[15:32:48.603]                             muffled <- TRUE
[15:32:48.603]                             break
[15:32:48.603]                           }
[15:32:48.603]                         }
[15:32:48.603]                       }
[15:32:48.603]                       invisible(muffled)
[15:32:48.603]                     }
[15:32:48.603]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.603]                   }
[15:32:48.603]                 }
[15:32:48.603]                 else {
[15:32:48.603]                   if (TRUE) {
[15:32:48.603]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.603]                     {
[15:32:48.603]                       inherits <- base::inherits
[15:32:48.603]                       invokeRestart <- base::invokeRestart
[15:32:48.603]                       is.null <- base::is.null
[15:32:48.603]                       muffled <- FALSE
[15:32:48.603]                       if (inherits(cond, "message")) {
[15:32:48.603]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.603]                         if (muffled) 
[15:32:48.603]                           invokeRestart("muffleMessage")
[15:32:48.603]                       }
[15:32:48.603]                       else if (inherits(cond, "warning")) {
[15:32:48.603]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.603]                         if (muffled) 
[15:32:48.603]                           invokeRestart("muffleWarning")
[15:32:48.603]                       }
[15:32:48.603]                       else if (inherits(cond, "condition")) {
[15:32:48.603]                         if (!is.null(pattern)) {
[15:32:48.603]                           computeRestarts <- base::computeRestarts
[15:32:48.603]                           grepl <- base::grepl
[15:32:48.603]                           restarts <- computeRestarts(cond)
[15:32:48.603]                           for (restart in restarts) {
[15:32:48.603]                             name <- restart$name
[15:32:48.603]                             if (is.null(name)) 
[15:32:48.603]                               next
[15:32:48.603]                             if (!grepl(pattern, name)) 
[15:32:48.603]                               next
[15:32:48.603]                             invokeRestart(restart)
[15:32:48.603]                             muffled <- TRUE
[15:32:48.603]                             break
[15:32:48.603]                           }
[15:32:48.603]                         }
[15:32:48.603]                       }
[15:32:48.603]                       invisible(muffled)
[15:32:48.603]                     }
[15:32:48.603]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.603]                   }
[15:32:48.603]                 }
[15:32:48.603]             }
[15:32:48.603]         }))
[15:32:48.603]     }, error = function(ex) {
[15:32:48.603]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:48.603]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.603]                 ...future.rng), started = ...future.startTime, 
[15:32:48.603]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:48.603]             version = "1.8"), class = "FutureResult")
[15:32:48.603]     }, finally = {
[15:32:48.603]         if (!identical(...future.workdir, getwd())) 
[15:32:48.603]             setwd(...future.workdir)
[15:32:48.603]         {
[15:32:48.603]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:48.603]                 ...future.oldOptions$nwarnings <- NULL
[15:32:48.603]             }
[15:32:48.603]             base::options(...future.oldOptions)
[15:32:48.603]             if (.Platform$OS.type == "windows") {
[15:32:48.603]                 old_names <- names(...future.oldEnvVars)
[15:32:48.603]                 envs <- base::Sys.getenv()
[15:32:48.603]                 names <- names(envs)
[15:32:48.603]                 common <- intersect(names, old_names)
[15:32:48.603]                 added <- setdiff(names, old_names)
[15:32:48.603]                 removed <- setdiff(old_names, names)
[15:32:48.603]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:48.603]                   envs[common]]
[15:32:48.603]                 NAMES <- toupper(changed)
[15:32:48.603]                 args <- list()
[15:32:48.603]                 for (kk in seq_along(NAMES)) {
[15:32:48.603]                   name <- changed[[kk]]
[15:32:48.603]                   NAME <- NAMES[[kk]]
[15:32:48.603]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.603]                     next
[15:32:48.603]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.603]                 }
[15:32:48.603]                 NAMES <- toupper(added)
[15:32:48.603]                 for (kk in seq_along(NAMES)) {
[15:32:48.603]                   name <- added[[kk]]
[15:32:48.603]                   NAME <- NAMES[[kk]]
[15:32:48.603]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.603]                     next
[15:32:48.603]                   args[[name]] <- ""
[15:32:48.603]                 }
[15:32:48.603]                 NAMES <- toupper(removed)
[15:32:48.603]                 for (kk in seq_along(NAMES)) {
[15:32:48.603]                   name <- removed[[kk]]
[15:32:48.603]                   NAME <- NAMES[[kk]]
[15:32:48.603]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.603]                     next
[15:32:48.603]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.603]                 }
[15:32:48.603]                 if (length(args) > 0) 
[15:32:48.603]                   base::do.call(base::Sys.setenv, args = args)
[15:32:48.603]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:48.603]             }
[15:32:48.603]             else {
[15:32:48.603]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:48.603]             }
[15:32:48.603]             {
[15:32:48.603]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:48.603]                   0L) {
[15:32:48.603]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:48.603]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:48.603]                   base::options(opts)
[15:32:48.603]                 }
[15:32:48.603]                 {
[15:32:48.603]                   {
[15:32:48.603]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:48.603]                     NULL
[15:32:48.603]                   }
[15:32:48.603]                   options(future.plan = NULL)
[15:32:48.603]                   if (is.na(NA_character_)) 
[15:32:48.603]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.603]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:48.603]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:48.603]                     .init = FALSE)
[15:32:48.603]                 }
[15:32:48.603]             }
[15:32:48.603]         }
[15:32:48.603]     })
[15:32:48.603]     if (TRUE) {
[15:32:48.603]         base::sink(type = "output", split = FALSE)
[15:32:48.603]         if (TRUE) {
[15:32:48.603]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:48.603]         }
[15:32:48.603]         else {
[15:32:48.603]             ...future.result["stdout"] <- base::list(NULL)
[15:32:48.603]         }
[15:32:48.603]         base::close(...future.stdout)
[15:32:48.603]         ...future.stdout <- NULL
[15:32:48.603]     }
[15:32:48.603]     ...future.result$conditions <- ...future.conditions
[15:32:48.603]     ...future.result$finished <- base::Sys.time()
[15:32:48.603]     ...future.result
[15:32:48.603] }
[15:32:48.613] Exporting 11 global objects (94.95 KiB) to cluster node #1 ...
[15:32:48.613] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:48.614] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:48.615] Exporting 'x_FUN' (2.90 KiB) to cluster node #1 ...
[15:32:48.615] Exporting 'x_FUN' (2.90 KiB) to cluster node #1 ... DONE
[15:32:48.616] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:48.617] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:48.617] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:48.618] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:48.619] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:48.619] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:48.620] Exporting 'dim' (56 bytes) to cluster node #1 ...
[15:32:48.620] Exporting 'dim' (56 bytes) to cluster node #1 ... DONE
[15:32:48.621] Exporting 'valid_types' (176 bytes) to cluster node #1 ...
[15:32:48.621] Exporting 'valid_types' (176 bytes) to cluster node #1 ... DONE
[15:32:48.622] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:48.622] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:48.622] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:48.623] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:48.623] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:48.624] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:48.624] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:48.625] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:48.625] Exporting 11 global objects (94.95 KiB) to cluster node #1 ... DONE
[15:32:48.627] MultisessionFuture started
[15:32:48.627] - Launch lazy future ... done
[15:32:48.627] run() for 'MultisessionFuture' ... done
[15:32:48.627] Created future:
[15:32:48.661] receiveMessageFromWorker() for ClusterFuture ...
[15:32:48.662] - Validating connection of MultisessionFuture
[15:32:48.662] - received message: FutureResult
[15:32:48.663] - Received FutureResult
[15:32:48.663] - Erased future from FutureRegistry
[15:32:48.663] result() for ClusterFuture ...
[15:32:48.664] - result already collected: FutureResult
[15:32:48.664] result() for ClusterFuture ... done
[15:32:48.664] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:48.628] MultisessionFuture:
[15:32:48.628] Label: 'future_vapply-2'
[15:32:48.628] Expression:
[15:32:48.628] {
[15:32:48.628]     do.call(function(...) {
[15:32:48.628]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.628]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.628]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.628]             on.exit(options(oopts), add = TRUE)
[15:32:48.628]         }
[15:32:48.628]         {
[15:32:48.628]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.628]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.628]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.628]             })
[15:32:48.628]         }
[15:32:48.628]     }, args = future.call.arguments)
[15:32:48.628] }
[15:32:48.628] Lazy evaluation: FALSE
[15:32:48.628] Asynchronous evaluation: TRUE
[15:32:48.628] Local evaluation: TRUE
[15:32:48.628] Environment: R_GlobalEnv
[15:32:48.628] Capture standard output: TRUE
[15:32:48.628] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:48.628] Globals: 11 objects totaling 95.23 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 2.90 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:48.628] Packages: 1 packages ('future.apply')
[15:32:48.628] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:48.628] Resolved: TRUE
[15:32:48.628] Value: <not collected>
[15:32:48.628] Conditions captured: <none>
[15:32:48.628] Early signaling: FALSE
[15:32:48.628] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:48.628] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.665] Chunk #2 of 2 ... DONE
[15:32:48.665] Launching 2 futures (chunks) ... DONE
[15:32:48.666] Resolving 2 futures (chunks) ...
[15:32:48.666] resolve() on list ...
[15:32:48.666]  recursive: 0
[15:32:48.667]  length: 2
[15:32:48.667] 
[15:32:48.667] Future #1
[15:32:48.668] result() for ClusterFuture ...
[15:32:48.668] - result already collected: FutureResult
[15:32:48.668] result() for ClusterFuture ... done
[15:32:48.668] result() for ClusterFuture ...
[15:32:48.669] - result already collected: FutureResult
[15:32:48.669] result() for ClusterFuture ... done
[15:32:48.669] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:48.670] - nx: 2
[15:32:48.670] - relay: TRUE
[15:32:48.670] - stdout: TRUE
[15:32:48.670] - signal: TRUE
[15:32:48.671] - resignal: FALSE
[15:32:48.671] - force: TRUE
[15:32:48.671] - relayed: [n=2] FALSE, FALSE
[15:32:48.671] - queued futures: [n=2] FALSE, FALSE
[15:32:48.672]  - until=1
[15:32:48.672]  - relaying element #1
[15:32:48.672] result() for ClusterFuture ...
[15:32:48.673] - result already collected: FutureResult
[15:32:48.673] result() for ClusterFuture ... done
[15:32:48.673] result() for ClusterFuture ...
[15:32:48.673] - result already collected: FutureResult
[15:32:48.674] result() for ClusterFuture ... done
[15:32:48.674] result() for ClusterFuture ...
[15:32:48.674] - result already collected: FutureResult
[15:32:48.675] result() for ClusterFuture ... done
[15:32:48.675] result() for ClusterFuture ...
[15:32:48.675] - result already collected: FutureResult
[15:32:48.676] result() for ClusterFuture ... done
[15:32:48.676] - relayed: [n=2] TRUE, FALSE
[15:32:48.676] - queued futures: [n=2] TRUE, FALSE
[15:32:48.676] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:48.677]  length: 1 (resolved future 1)
[15:32:48.677] Future #2
[15:32:48.677] result() for ClusterFuture ...
[15:32:48.678] - result already collected: FutureResult
[15:32:48.678] result() for ClusterFuture ... done
[15:32:48.678] result() for ClusterFuture ...
[15:32:48.678] - result already collected: FutureResult
[15:32:48.679] result() for ClusterFuture ... done
[15:32:48.679] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:48.679] - nx: 2
[15:32:48.680] - relay: TRUE
[15:32:48.680] - stdout: TRUE
[15:32:48.680] - signal: TRUE
[15:32:48.680] - resignal: FALSE
[15:32:48.681] - force: TRUE
[15:32:48.681] - relayed: [n=2] TRUE, FALSE
[15:32:48.681] - queued futures: [n=2] TRUE, FALSE
[15:32:48.682]  - until=2
[15:32:48.682]  - relaying element #2
[15:32:48.682] result() for ClusterFuture ...
[15:32:48.682] - result already collected: FutureResult
[15:32:48.683] result() for ClusterFuture ... done
[15:32:48.683] result() for ClusterFuture ...
[15:32:48.683] - result already collected: FutureResult
[15:32:48.684] result() for ClusterFuture ... done
[15:32:48.684] result() for ClusterFuture ...
[15:32:48.684] - result already collected: FutureResult
[15:32:48.684] result() for ClusterFuture ... done
[15:32:48.685] result() for ClusterFuture ...
[15:32:48.685] - result already collected: FutureResult
[15:32:48.685] result() for ClusterFuture ... done
[15:32:48.686] - relayed: [n=2] TRUE, TRUE
[15:32:48.686] - queued futures: [n=2] TRUE, TRUE
[15:32:48.686] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:48.686]  length: 0 (resolved future 2)
[15:32:48.687] Relaying remaining futures
[15:32:48.687] signalConditionsASAP(NULL, pos=0) ...
[15:32:48.687] - nx: 2
[15:32:48.688] - relay: TRUE
[15:32:48.688] - stdout: TRUE
[15:32:48.688] - signal: TRUE
[15:32:48.688] - resignal: FALSE
[15:32:48.689] - force: TRUE
[15:32:48.689] - relayed: [n=2] TRUE, TRUE
[15:32:48.689] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:48.690] - relayed: [n=2] TRUE, TRUE
[15:32:48.690] - queued futures: [n=2] TRUE, TRUE
[15:32:48.690] signalConditionsASAP(NULL, pos=0) ... done
[15:32:48.690] resolve() on list ... DONE
[15:32:48.691] result() for ClusterFuture ...
[15:32:48.691] - result already collected: FutureResult
[15:32:48.691] result() for ClusterFuture ... done
[15:32:48.692] result() for ClusterFuture ...
[15:32:48.692] - result already collected: FutureResult
[15:32:48.692] result() for ClusterFuture ... done
[15:32:48.692] result() for ClusterFuture ...
[15:32:48.693] - result already collected: FutureResult
[15:32:48.693] result() for ClusterFuture ... done
[15:32:48.693] result() for ClusterFuture ...
[15:32:48.694] - result already collected: FutureResult
[15:32:48.694] result() for ClusterFuture ... done
[15:32:48.694]  - Number of value chunks collected: 2
[15:32:48.694] Resolving 2 futures (chunks) ... DONE
[15:32:48.695] Reducing values from 2 chunks ...
[15:32:48.695]  - Number of values collected after concatenation: 10
[15:32:48.695]  - Number of values expected: 10
[15:32:48.695] Reducing values from 2 chunks ... DONE
[15:32:48.696] future_lapply() ... DONE
 int [1:2, 1:2, 1:10] 1 1 1 1 2 2 2 2 3 3 ...
 num [1:2, 1:2, 1:10] 1 1 1 1 2 2 2 2 3 3 ...
[15:32:48.698] future_lapply() ...
[15:32:48.706] Number of chunks: 2
[15:32:48.706] getGlobalsAndPackagesXApply() ...
[15:32:48.706]  - future.globals: TRUE
[15:32:48.707] getGlobalsAndPackages() ...
[15:32:48.707] Searching for globals...
[15:32:48.714] - globals found: [17] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'matrix'
[15:32:48.715] Searching for globals ... DONE
[15:32:48.715] Resolving globals: FALSE
[15:32:48.717] The total size of the 7 globals is 95.02 KiB (97304 bytes)
[15:32:48.718] The total size of the 7 globals exported for future expression ('FUN()') is 95.02 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:48.718] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:48.718] - packages: [1] 'future.apply'
[15:32:48.719] getGlobalsAndPackages() ... DONE
[15:32:48.719]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:48.719]  - needed namespaces: [n=1] 'future.apply'
[15:32:48.719] Finding globals ... DONE
[15:32:48.720]  - use_args: TRUE
[15:32:48.720]  - Getting '...' globals ...
[15:32:48.721] resolve() on list ...
[15:32:48.721]  recursive: 0
[15:32:48.721]  length: 1
[15:32:48.722]  elements: '...'
[15:32:48.722]  length: 0 (resolved future 1)
[15:32:48.722] resolve() on list ... DONE
[15:32:48.723]    - '...' content: [n=0] 
[15:32:48.723] List of 1
[15:32:48.723]  $ ...: list()
[15:32:48.723]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:48.723]  - attr(*, "where")=List of 1
[15:32:48.723]   ..$ ...:<environment: 0x0000022d41272d48> 
[15:32:48.723]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:48.723]  - attr(*, "resolved")= logi TRUE
[15:32:48.723]  - attr(*, "total_size")= num NA
[15:32:48.728]  - Getting '...' globals ... DONE
[15:32:48.728] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:48.728] List of 8
[15:32:48.728]  $ ...future.FUN:function (x, ...)  
[15:32:48.728]  $ x_FUN        :function (x)  
[15:32:48.728]  $ times        : int 4
[15:32:48.728]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:48.728]  $ stop_if_not  :function (...)  
[15:32:48.728]  $ dim          : int [1:2] 2 2
[15:32:48.728]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:48.728]  $ ...          : list()
[15:32:48.728]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:48.728]  - attr(*, "where")=List of 8
[15:32:48.728]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:48.728]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:48.728]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:48.728]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:48.728]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:48.728]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:48.728]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:48.728]   ..$ ...          :<environment: 0x0000022d41272d48> 
[15:32:48.728]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:48.728]  - attr(*, "resolved")= logi FALSE
[15:32:48.728]  - attr(*, "total_size")= num 97304
[15:32:48.739] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:48.739] getGlobalsAndPackagesXApply() ... DONE
[15:32:48.740] Number of futures (= number of chunks): 2
[15:32:48.740] Launching 2 futures (chunks) ...
[15:32:48.740] Chunk #1 of 2 ...
[15:32:48.741]  - Finding globals in 'X' for chunk #1 ...
[15:32:48.741] getGlobalsAndPackages() ...
[15:32:48.741] Searching for globals...
[15:32:48.742] 
[15:32:48.742] Searching for globals ... DONE
[15:32:48.742] - globals: [0] <none>
[15:32:48.742] getGlobalsAndPackages() ... DONE
[15:32:48.742]    + additional globals found: [n=0] 
[15:32:48.743]    + additional namespaces needed: [n=0] 
[15:32:48.743]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:48.743]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:48.743]  - seeds: <none>
[15:32:48.744]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.744] getGlobalsAndPackages() ...
[15:32:48.744] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.745] Resolving globals: FALSE
[15:32:48.745] Tweak future expression to call with '...' arguments ...
[15:32:48.745] {
[15:32:48.745]     do.call(function(...) {
[15:32:48.745]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.745]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.745]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.745]             on.exit(options(oopts), add = TRUE)
[15:32:48.745]         }
[15:32:48.745]         {
[15:32:48.745]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.745]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.745]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.745]             })
[15:32:48.745]         }
[15:32:48.745]     }, args = future.call.arguments)
[15:32:48.745] }
[15:32:48.746] Tweak future expression to call with '...' arguments ... DONE
[15:32:48.747] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.747] - packages: [1] 'future.apply'
[15:32:48.747] getGlobalsAndPackages() ... DONE
[15:32:48.748] run() for 'Future' ...
[15:32:48.748] - state: 'created'
[15:32:48.749] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:48.767] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.767] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:48.767]   - Field: 'node'
[15:32:48.768]   - Field: 'label'
[15:32:48.768]   - Field: 'local'
[15:32:48.768]   - Field: 'owner'
[15:32:48.769]   - Field: 'envir'
[15:32:48.769]   - Field: 'workers'
[15:32:48.769]   - Field: 'packages'
[15:32:48.769]   - Field: 'gc'
[15:32:48.770]   - Field: 'conditions'
[15:32:48.770]   - Field: 'persistent'
[15:32:48.770]   - Field: 'expr'
[15:32:48.770]   - Field: 'uuid'
[15:32:48.771]   - Field: 'seed'
[15:32:48.771]   - Field: 'version'
[15:32:48.771]   - Field: 'result'
[15:32:48.772]   - Field: 'asynchronous'
[15:32:48.772]   - Field: 'calls'
[15:32:48.772]   - Field: 'globals'
[15:32:48.772]   - Field: 'stdout'
[15:32:48.776]   - Field: 'earlySignal'
[15:32:48.776]   - Field: 'lazy'
[15:32:48.776]   - Field: 'state'
[15:32:48.777] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:48.777] - Launch lazy future ...
[15:32:48.777] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:48.778] Packages needed by future strategies (n = 0): <none>
[15:32:48.779] {
[15:32:48.779]     {
[15:32:48.779]         {
[15:32:48.779]             ...future.startTime <- base::Sys.time()
[15:32:48.779]             {
[15:32:48.779]                 {
[15:32:48.779]                   {
[15:32:48.779]                     {
[15:32:48.779]                       {
[15:32:48.779]                         base::local({
[15:32:48.779]                           has_future <- base::requireNamespace("future", 
[15:32:48.779]                             quietly = TRUE)
[15:32:48.779]                           if (has_future) {
[15:32:48.779]                             ns <- base::getNamespace("future")
[15:32:48.779]                             version <- ns[[".package"]][["version"]]
[15:32:48.779]                             if (is.null(version)) 
[15:32:48.779]                               version <- utils::packageVersion("future")
[15:32:48.779]                           }
[15:32:48.779]                           else {
[15:32:48.779]                             version <- NULL
[15:32:48.779]                           }
[15:32:48.779]                           if (!has_future || version < "1.8.0") {
[15:32:48.779]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:48.779]                               "", base::R.version$version.string), 
[15:32:48.779]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:48.779]                                 base::R.version$platform, 8 * 
[15:32:48.779]                                   base::.Machine$sizeof.pointer), 
[15:32:48.779]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:48.779]                                 "release", "version")], collapse = " "), 
[15:32:48.779]                               hostname = base::Sys.info()[["nodename"]])
[15:32:48.779]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:48.779]                               info)
[15:32:48.779]                             info <- base::paste(info, collapse = "; ")
[15:32:48.779]                             if (!has_future) {
[15:32:48.779]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:48.779]                                 info)
[15:32:48.779]                             }
[15:32:48.779]                             else {
[15:32:48.779]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:48.779]                                 info, version)
[15:32:48.779]                             }
[15:32:48.779]                             base::stop(msg)
[15:32:48.779]                           }
[15:32:48.779]                         })
[15:32:48.779]                       }
[15:32:48.779]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:48.779]                       base::options(mc.cores = 1L)
[15:32:48.779]                     }
[15:32:48.779]                     base::local({
[15:32:48.779]                       for (pkg in "future.apply") {
[15:32:48.779]                         base::loadNamespace(pkg)
[15:32:48.779]                         base::library(pkg, character.only = TRUE)
[15:32:48.779]                       }
[15:32:48.779]                     })
[15:32:48.779]                   }
[15:32:48.779]                   ...future.strategy.old <- future::plan("list")
[15:32:48.779]                   options(future.plan = NULL)
[15:32:48.779]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.779]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:48.779]                 }
[15:32:48.779]                 ...future.workdir <- getwd()
[15:32:48.779]             }
[15:32:48.779]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:48.779]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:48.779]         }
[15:32:48.779]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:48.779]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:48.779]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:48.779]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:48.779]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:48.779]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:48.779]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:48.779]             base::names(...future.oldOptions))
[15:32:48.779]     }
[15:32:48.779]     if (FALSE) {
[15:32:48.779]     }
[15:32:48.779]     else {
[15:32:48.779]         if (TRUE) {
[15:32:48.779]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:48.779]                 open = "w")
[15:32:48.779]         }
[15:32:48.779]         else {
[15:32:48.779]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:48.779]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:48.779]         }
[15:32:48.779]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:48.779]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:48.779]             base::sink(type = "output", split = FALSE)
[15:32:48.779]             base::close(...future.stdout)
[15:32:48.779]         }, add = TRUE)
[15:32:48.779]     }
[15:32:48.779]     ...future.frame <- base::sys.nframe()
[15:32:48.779]     ...future.conditions <- base::list()
[15:32:48.779]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:48.779]     if (FALSE) {
[15:32:48.779]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:48.779]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:48.779]     }
[15:32:48.779]     ...future.result <- base::tryCatch({
[15:32:48.779]         base::withCallingHandlers({
[15:32:48.779]             ...future.value <- base::withVisible(base::local({
[15:32:48.779]                 ...future.makeSendCondition <- base::local({
[15:32:48.779]                   sendCondition <- NULL
[15:32:48.779]                   function(frame = 1L) {
[15:32:48.779]                     if (is.function(sendCondition)) 
[15:32:48.779]                       return(sendCondition)
[15:32:48.779]                     ns <- getNamespace("parallel")
[15:32:48.779]                     if (exists("sendData", mode = "function", 
[15:32:48.779]                       envir = ns)) {
[15:32:48.779]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:48.779]                         envir = ns)
[15:32:48.779]                       envir <- sys.frame(frame)
[15:32:48.779]                       master <- NULL
[15:32:48.779]                       while (!identical(envir, .GlobalEnv) && 
[15:32:48.779]                         !identical(envir, emptyenv())) {
[15:32:48.779]                         if (exists("master", mode = "list", envir = envir, 
[15:32:48.779]                           inherits = FALSE)) {
[15:32:48.779]                           master <- get("master", mode = "list", 
[15:32:48.779]                             envir = envir, inherits = FALSE)
[15:32:48.779]                           if (inherits(master, c("SOCKnode", 
[15:32:48.779]                             "SOCK0node"))) {
[15:32:48.779]                             sendCondition <<- function(cond) {
[15:32:48.779]                               data <- list(type = "VALUE", value = cond, 
[15:32:48.779]                                 success = TRUE)
[15:32:48.779]                               parallel_sendData(master, data)
[15:32:48.779]                             }
[15:32:48.779]                             return(sendCondition)
[15:32:48.779]                           }
[15:32:48.779]                         }
[15:32:48.779]                         frame <- frame + 1L
[15:32:48.779]                         envir <- sys.frame(frame)
[15:32:48.779]                       }
[15:32:48.779]                     }
[15:32:48.779]                     sendCondition <<- function(cond) NULL
[15:32:48.779]                   }
[15:32:48.779]                 })
[15:32:48.779]                 withCallingHandlers({
[15:32:48.779]                   {
[15:32:48.779]                     do.call(function(...) {
[15:32:48.779]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.779]                       if (!identical(...future.globals.maxSize.org, 
[15:32:48.779]                         ...future.globals.maxSize)) {
[15:32:48.779]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.779]                         on.exit(options(oopts), add = TRUE)
[15:32:48.779]                       }
[15:32:48.779]                       {
[15:32:48.779]                         lapply(seq_along(...future.elements_ii), 
[15:32:48.779]                           FUN = function(jj) {
[15:32:48.779]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.779]                             ...future.FUN(...future.X_jj, ...)
[15:32:48.779]                           })
[15:32:48.779]                       }
[15:32:48.779]                     }, args = future.call.arguments)
[15:32:48.779]                   }
[15:32:48.779]                 }, immediateCondition = function(cond) {
[15:32:48.779]                   sendCondition <- ...future.makeSendCondition()
[15:32:48.779]                   sendCondition(cond)
[15:32:48.779]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.779]                   {
[15:32:48.779]                     inherits <- base::inherits
[15:32:48.779]                     invokeRestart <- base::invokeRestart
[15:32:48.779]                     is.null <- base::is.null
[15:32:48.779]                     muffled <- FALSE
[15:32:48.779]                     if (inherits(cond, "message")) {
[15:32:48.779]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:48.779]                       if (muffled) 
[15:32:48.779]                         invokeRestart("muffleMessage")
[15:32:48.779]                     }
[15:32:48.779]                     else if (inherits(cond, "warning")) {
[15:32:48.779]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:48.779]                       if (muffled) 
[15:32:48.779]                         invokeRestart("muffleWarning")
[15:32:48.779]                     }
[15:32:48.779]                     else if (inherits(cond, "condition")) {
[15:32:48.779]                       if (!is.null(pattern)) {
[15:32:48.779]                         computeRestarts <- base::computeRestarts
[15:32:48.779]                         grepl <- base::grepl
[15:32:48.779]                         restarts <- computeRestarts(cond)
[15:32:48.779]                         for (restart in restarts) {
[15:32:48.779]                           name <- restart$name
[15:32:48.779]                           if (is.null(name)) 
[15:32:48.779]                             next
[15:32:48.779]                           if (!grepl(pattern, name)) 
[15:32:48.779]                             next
[15:32:48.779]                           invokeRestart(restart)
[15:32:48.779]                           muffled <- TRUE
[15:32:48.779]                           break
[15:32:48.779]                         }
[15:32:48.779]                       }
[15:32:48.779]                     }
[15:32:48.779]                     invisible(muffled)
[15:32:48.779]                   }
[15:32:48.779]                   muffleCondition(cond)
[15:32:48.779]                 })
[15:32:48.779]             }))
[15:32:48.779]             future::FutureResult(value = ...future.value$value, 
[15:32:48.779]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.779]                   ...future.rng), globalenv = if (FALSE) 
[15:32:48.779]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:48.779]                     ...future.globalenv.names))
[15:32:48.779]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:48.779]         }, condition = base::local({
[15:32:48.779]             c <- base::c
[15:32:48.779]             inherits <- base::inherits
[15:32:48.779]             invokeRestart <- base::invokeRestart
[15:32:48.779]             length <- base::length
[15:32:48.779]             list <- base::list
[15:32:48.779]             seq.int <- base::seq.int
[15:32:48.779]             signalCondition <- base::signalCondition
[15:32:48.779]             sys.calls <- base::sys.calls
[15:32:48.779]             `[[` <- base::`[[`
[15:32:48.779]             `+` <- base::`+`
[15:32:48.779]             `<<-` <- base::`<<-`
[15:32:48.779]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:48.779]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:48.779]                   3L)]
[15:32:48.779]             }
[15:32:48.779]             function(cond) {
[15:32:48.779]                 is_error <- inherits(cond, "error")
[15:32:48.779]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:48.779]                   NULL)
[15:32:48.779]                 if (is_error) {
[15:32:48.779]                   sessionInformation <- function() {
[15:32:48.779]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:48.779]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:48.779]                       search = base::search(), system = base::Sys.info())
[15:32:48.779]                   }
[15:32:48.779]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.779]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:48.779]                     cond$call), session = sessionInformation(), 
[15:32:48.779]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:48.779]                   signalCondition(cond)
[15:32:48.779]                 }
[15:32:48.779]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:48.779]                 "immediateCondition"))) {
[15:32:48.779]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:48.779]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.779]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:48.779]                   if (TRUE && !signal) {
[15:32:48.779]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.779]                     {
[15:32:48.779]                       inherits <- base::inherits
[15:32:48.779]                       invokeRestart <- base::invokeRestart
[15:32:48.779]                       is.null <- base::is.null
[15:32:48.779]                       muffled <- FALSE
[15:32:48.779]                       if (inherits(cond, "message")) {
[15:32:48.779]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.779]                         if (muffled) 
[15:32:48.779]                           invokeRestart("muffleMessage")
[15:32:48.779]                       }
[15:32:48.779]                       else if (inherits(cond, "warning")) {
[15:32:48.779]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.779]                         if (muffled) 
[15:32:48.779]                           invokeRestart("muffleWarning")
[15:32:48.779]                       }
[15:32:48.779]                       else if (inherits(cond, "condition")) {
[15:32:48.779]                         if (!is.null(pattern)) {
[15:32:48.779]                           computeRestarts <- base::computeRestarts
[15:32:48.779]                           grepl <- base::grepl
[15:32:48.779]                           restarts <- computeRestarts(cond)
[15:32:48.779]                           for (restart in restarts) {
[15:32:48.779]                             name <- restart$name
[15:32:48.779]                             if (is.null(name)) 
[15:32:48.779]                               next
[15:32:48.779]                             if (!grepl(pattern, name)) 
[15:32:48.779]                               next
[15:32:48.779]                             invokeRestart(restart)
[15:32:48.779]                             muffled <- TRUE
[15:32:48.779]                             break
[15:32:48.779]                           }
[15:32:48.779]                         }
[15:32:48.779]                       }
[15:32:48.779]                       invisible(muffled)
[15:32:48.779]                     }
[15:32:48.779]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.779]                   }
[15:32:48.779]                 }
[15:32:48.779]                 else {
[15:32:48.779]                   if (TRUE) {
[15:32:48.779]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.779]                     {
[15:32:48.779]                       inherits <- base::inherits
[15:32:48.779]                       invokeRestart <- base::invokeRestart
[15:32:48.779]                       is.null <- base::is.null
[15:32:48.779]                       muffled <- FALSE
[15:32:48.779]                       if (inherits(cond, "message")) {
[15:32:48.779]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.779]                         if (muffled) 
[15:32:48.779]                           invokeRestart("muffleMessage")
[15:32:48.779]                       }
[15:32:48.779]                       else if (inherits(cond, "warning")) {
[15:32:48.779]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.779]                         if (muffled) 
[15:32:48.779]                           invokeRestart("muffleWarning")
[15:32:48.779]                       }
[15:32:48.779]                       else if (inherits(cond, "condition")) {
[15:32:48.779]                         if (!is.null(pattern)) {
[15:32:48.779]                           computeRestarts <- base::computeRestarts
[15:32:48.779]                           grepl <- base::grepl
[15:32:48.779]                           restarts <- computeRestarts(cond)
[15:32:48.779]                           for (restart in restarts) {
[15:32:48.779]                             name <- restart$name
[15:32:48.779]                             if (is.null(name)) 
[15:32:48.779]                               next
[15:32:48.779]                             if (!grepl(pattern, name)) 
[15:32:48.779]                               next
[15:32:48.779]                             invokeRestart(restart)
[15:32:48.779]                             muffled <- TRUE
[15:32:48.779]                             break
[15:32:48.779]                           }
[15:32:48.779]                         }
[15:32:48.779]                       }
[15:32:48.779]                       invisible(muffled)
[15:32:48.779]                     }
[15:32:48.779]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.779]                   }
[15:32:48.779]                 }
[15:32:48.779]             }
[15:32:48.779]         }))
[15:32:48.779]     }, error = function(ex) {
[15:32:48.779]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:48.779]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.779]                 ...future.rng), started = ...future.startTime, 
[15:32:48.779]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:48.779]             version = "1.8"), class = "FutureResult")
[15:32:48.779]     }, finally = {
[15:32:48.779]         if (!identical(...future.workdir, getwd())) 
[15:32:48.779]             setwd(...future.workdir)
[15:32:48.779]         {
[15:32:48.779]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:48.779]                 ...future.oldOptions$nwarnings <- NULL
[15:32:48.779]             }
[15:32:48.779]             base::options(...future.oldOptions)
[15:32:48.779]             if (.Platform$OS.type == "windows") {
[15:32:48.779]                 old_names <- names(...future.oldEnvVars)
[15:32:48.779]                 envs <- base::Sys.getenv()
[15:32:48.779]                 names <- names(envs)
[15:32:48.779]                 common <- intersect(names, old_names)
[15:32:48.779]                 added <- setdiff(names, old_names)
[15:32:48.779]                 removed <- setdiff(old_names, names)
[15:32:48.779]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:48.779]                   envs[common]]
[15:32:48.779]                 NAMES <- toupper(changed)
[15:32:48.779]                 args <- list()
[15:32:48.779]                 for (kk in seq_along(NAMES)) {
[15:32:48.779]                   name <- changed[[kk]]
[15:32:48.779]                   NAME <- NAMES[[kk]]
[15:32:48.779]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.779]                     next
[15:32:48.779]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.779]                 }
[15:32:48.779]                 NAMES <- toupper(added)
[15:32:48.779]                 for (kk in seq_along(NAMES)) {
[15:32:48.779]                   name <- added[[kk]]
[15:32:48.779]                   NAME <- NAMES[[kk]]
[15:32:48.779]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.779]                     next
[15:32:48.779]                   args[[name]] <- ""
[15:32:48.779]                 }
[15:32:48.779]                 NAMES <- toupper(removed)
[15:32:48.779]                 for (kk in seq_along(NAMES)) {
[15:32:48.779]                   name <- removed[[kk]]
[15:32:48.779]                   NAME <- NAMES[[kk]]
[15:32:48.779]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.779]                     next
[15:32:48.779]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.779]                 }
[15:32:48.779]                 if (length(args) > 0) 
[15:32:48.779]                   base::do.call(base::Sys.setenv, args = args)
[15:32:48.779]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:48.779]             }
[15:32:48.779]             else {
[15:32:48.779]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:48.779]             }
[15:32:48.779]             {
[15:32:48.779]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:48.779]                   0L) {
[15:32:48.779]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:48.779]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:48.779]                   base::options(opts)
[15:32:48.779]                 }
[15:32:48.779]                 {
[15:32:48.779]                   {
[15:32:48.779]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:48.779]                     NULL
[15:32:48.779]                   }
[15:32:48.779]                   options(future.plan = NULL)
[15:32:48.779]                   if (is.na(NA_character_)) 
[15:32:48.779]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.779]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:48.779]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:48.779]                     .init = FALSE)
[15:32:48.779]                 }
[15:32:48.779]             }
[15:32:48.779]         }
[15:32:48.779]     })
[15:32:48.779]     if (TRUE) {
[15:32:48.779]         base::sink(type = "output", split = FALSE)
[15:32:48.779]         if (TRUE) {
[15:32:48.779]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:48.779]         }
[15:32:48.779]         else {
[15:32:48.779]             ...future.result["stdout"] <- base::list(NULL)
[15:32:48.779]         }
[15:32:48.779]         base::close(...future.stdout)
[15:32:48.779]         ...future.stdout <- NULL
[15:32:48.779]     }
[15:32:48.779]     ...future.result$conditions <- ...future.conditions
[15:32:48.779]     ...future.result$finished <- base::Sys.time()
[15:32:48.779]     ...future.result
[15:32:48.779] }
[15:32:48.787] Exporting 11 global objects (95.02 KiB) to cluster node #1 ...
[15:32:48.788] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:48.789] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:48.789] Exporting 'x_FUN' (2.90 KiB) to cluster node #1 ...
[15:32:48.790] Exporting 'x_FUN' (2.90 KiB) to cluster node #1 ... DONE
[15:32:48.790] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:48.790] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:48.791] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:48.791] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:48.791] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:48.792] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:48.792] Exporting 'dim' (56 bytes) to cluster node #1 ...
[15:32:48.793] Exporting 'dim' (56 bytes) to cluster node #1 ... DONE
[15:32:48.793] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:48.793] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:48.793] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:48.794] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:48.794] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:48.794] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:48.795] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:48.795] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:48.795] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:48.796] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:48.796] Exporting 11 global objects (95.02 KiB) to cluster node #1 ... DONE
[15:32:48.797] MultisessionFuture started
[15:32:48.797] - Launch lazy future ... done
[15:32:48.797] run() for 'MultisessionFuture' ... done
[15:32:48.797] Created future:
[15:32:48.816] receiveMessageFromWorker() for ClusterFuture ...
[15:32:48.817] - Validating connection of MultisessionFuture
[15:32:48.817] - received message: FutureResult
[15:32:48.817] - Received FutureResult
[15:32:48.817] - Erased future from FutureRegistry
[15:32:48.818] result() for ClusterFuture ...
[15:32:48.818] - result already collected: FutureResult
[15:32:48.818] result() for ClusterFuture ... done
[15:32:48.818] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:48.797] MultisessionFuture:
[15:32:48.797] Label: 'future_vapply-1'
[15:32:48.797] Expression:
[15:32:48.797] {
[15:32:48.797]     do.call(function(...) {
[15:32:48.797]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.797]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.797]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.797]             on.exit(options(oopts), add = TRUE)
[15:32:48.797]         }
[15:32:48.797]         {
[15:32:48.797]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.797]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.797]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.797]             })
[15:32:48.797]         }
[15:32:48.797]     }, args = future.call.arguments)
[15:32:48.797] }
[15:32:48.797] Lazy evaluation: FALSE
[15:32:48.797] Asynchronous evaluation: TRUE
[15:32:48.797] Local evaluation: TRUE
[15:32:48.797] Environment: R_GlobalEnv
[15:32:48.797] Capture standard output: TRUE
[15:32:48.797] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:48.797] Globals: 11 objects totaling 95.30 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 2.90 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:48.797] Packages: 1 packages ('future.apply')
[15:32:48.797] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:48.797] Resolved: TRUE
[15:32:48.797] Value: <not collected>
[15:32:48.797] Conditions captured: <none>
[15:32:48.797] Early signaling: FALSE
[15:32:48.797] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:48.797] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.819] Chunk #1 of 2 ... DONE
[15:32:48.819] Chunk #2 of 2 ...
[15:32:48.819]  - Finding globals in 'X' for chunk #2 ...
[15:32:48.819] getGlobalsAndPackages() ...
[15:32:48.819] Searching for globals...
[15:32:48.820] 
[15:32:48.820] Searching for globals ... DONE
[15:32:48.820] - globals: [0] <none>
[15:32:48.820] getGlobalsAndPackages() ... DONE
[15:32:48.820]    + additional globals found: [n=0] 
[15:32:48.821]    + additional namespaces needed: [n=0] 
[15:32:48.821]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:48.821]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:48.821]  - seeds: <none>
[15:32:48.821]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.822] getGlobalsAndPackages() ...
[15:32:48.822] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.822] Resolving globals: FALSE
[15:32:48.822] Tweak future expression to call with '...' arguments ...
[15:32:48.822] {
[15:32:48.822]     do.call(function(...) {
[15:32:48.822]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.822]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.822]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.822]             on.exit(options(oopts), add = TRUE)
[15:32:48.822]         }
[15:32:48.822]         {
[15:32:48.822]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.822]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.822]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.822]             })
[15:32:48.822]         }
[15:32:48.822]     }, args = future.call.arguments)
[15:32:48.822] }
[15:32:48.823] Tweak future expression to call with '...' arguments ... DONE
[15:32:48.823] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.824] - packages: [1] 'future.apply'
[15:32:48.824] getGlobalsAndPackages() ... DONE
[15:32:48.824] run() for 'Future' ...
[15:32:48.825] - state: 'created'
[15:32:48.825] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:48.840] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.840] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:48.840]   - Field: 'node'
[15:32:48.841]   - Field: 'label'
[15:32:48.841]   - Field: 'local'
[15:32:48.841]   - Field: 'owner'
[15:32:48.841]   - Field: 'envir'
[15:32:48.841]   - Field: 'workers'
[15:32:48.842]   - Field: 'packages'
[15:32:48.842]   - Field: 'gc'
[15:32:48.842]   - Field: 'conditions'
[15:32:48.842]   - Field: 'persistent'
[15:32:48.842]   - Field: 'expr'
[15:32:48.842]   - Field: 'uuid'
[15:32:48.843]   - Field: 'seed'
[15:32:48.843]   - Field: 'version'
[15:32:48.843]   - Field: 'result'
[15:32:48.843]   - Field: 'asynchronous'
[15:32:48.843]   - Field: 'calls'
[15:32:48.844]   - Field: 'globals'
[15:32:48.844]   - Field: 'stdout'
[15:32:48.844]   - Field: 'earlySignal'
[15:32:48.844]   - Field: 'lazy'
[15:32:48.844]   - Field: 'state'
[15:32:48.844] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:48.845] - Launch lazy future ...
[15:32:48.845] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:48.845] Packages needed by future strategies (n = 0): <none>
[15:32:48.846] {
[15:32:48.846]     {
[15:32:48.846]         {
[15:32:48.846]             ...future.startTime <- base::Sys.time()
[15:32:48.846]             {
[15:32:48.846]                 {
[15:32:48.846]                   {
[15:32:48.846]                     {
[15:32:48.846]                       {
[15:32:48.846]                         base::local({
[15:32:48.846]                           has_future <- base::requireNamespace("future", 
[15:32:48.846]                             quietly = TRUE)
[15:32:48.846]                           if (has_future) {
[15:32:48.846]                             ns <- base::getNamespace("future")
[15:32:48.846]                             version <- ns[[".package"]][["version"]]
[15:32:48.846]                             if (is.null(version)) 
[15:32:48.846]                               version <- utils::packageVersion("future")
[15:32:48.846]                           }
[15:32:48.846]                           else {
[15:32:48.846]                             version <- NULL
[15:32:48.846]                           }
[15:32:48.846]                           if (!has_future || version < "1.8.0") {
[15:32:48.846]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:48.846]                               "", base::R.version$version.string), 
[15:32:48.846]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:48.846]                                 base::R.version$platform, 8 * 
[15:32:48.846]                                   base::.Machine$sizeof.pointer), 
[15:32:48.846]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:48.846]                                 "release", "version")], collapse = " "), 
[15:32:48.846]                               hostname = base::Sys.info()[["nodename"]])
[15:32:48.846]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:48.846]                               info)
[15:32:48.846]                             info <- base::paste(info, collapse = "; ")
[15:32:48.846]                             if (!has_future) {
[15:32:48.846]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:48.846]                                 info)
[15:32:48.846]                             }
[15:32:48.846]                             else {
[15:32:48.846]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:48.846]                                 info, version)
[15:32:48.846]                             }
[15:32:48.846]                             base::stop(msg)
[15:32:48.846]                           }
[15:32:48.846]                         })
[15:32:48.846]                       }
[15:32:48.846]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:48.846]                       base::options(mc.cores = 1L)
[15:32:48.846]                     }
[15:32:48.846]                     base::local({
[15:32:48.846]                       for (pkg in "future.apply") {
[15:32:48.846]                         base::loadNamespace(pkg)
[15:32:48.846]                         base::library(pkg, character.only = TRUE)
[15:32:48.846]                       }
[15:32:48.846]                     })
[15:32:48.846]                   }
[15:32:48.846]                   ...future.strategy.old <- future::plan("list")
[15:32:48.846]                   options(future.plan = NULL)
[15:32:48.846]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.846]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:48.846]                 }
[15:32:48.846]                 ...future.workdir <- getwd()
[15:32:48.846]             }
[15:32:48.846]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:48.846]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:48.846]         }
[15:32:48.846]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:48.846]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:48.846]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:48.846]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:48.846]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:48.846]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:48.846]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:48.846]             base::names(...future.oldOptions))
[15:32:48.846]     }
[15:32:48.846]     if (FALSE) {
[15:32:48.846]     }
[15:32:48.846]     else {
[15:32:48.846]         if (TRUE) {
[15:32:48.846]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:48.846]                 open = "w")
[15:32:48.846]         }
[15:32:48.846]         else {
[15:32:48.846]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:48.846]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:48.846]         }
[15:32:48.846]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:48.846]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:48.846]             base::sink(type = "output", split = FALSE)
[15:32:48.846]             base::close(...future.stdout)
[15:32:48.846]         }, add = TRUE)
[15:32:48.846]     }
[15:32:48.846]     ...future.frame <- base::sys.nframe()
[15:32:48.846]     ...future.conditions <- base::list()
[15:32:48.846]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:48.846]     if (FALSE) {
[15:32:48.846]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:48.846]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:48.846]     }
[15:32:48.846]     ...future.result <- base::tryCatch({
[15:32:48.846]         base::withCallingHandlers({
[15:32:48.846]             ...future.value <- base::withVisible(base::local({
[15:32:48.846]                 ...future.makeSendCondition <- base::local({
[15:32:48.846]                   sendCondition <- NULL
[15:32:48.846]                   function(frame = 1L) {
[15:32:48.846]                     if (is.function(sendCondition)) 
[15:32:48.846]                       return(sendCondition)
[15:32:48.846]                     ns <- getNamespace("parallel")
[15:32:48.846]                     if (exists("sendData", mode = "function", 
[15:32:48.846]                       envir = ns)) {
[15:32:48.846]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:48.846]                         envir = ns)
[15:32:48.846]                       envir <- sys.frame(frame)
[15:32:48.846]                       master <- NULL
[15:32:48.846]                       while (!identical(envir, .GlobalEnv) && 
[15:32:48.846]                         !identical(envir, emptyenv())) {
[15:32:48.846]                         if (exists("master", mode = "list", envir = envir, 
[15:32:48.846]                           inherits = FALSE)) {
[15:32:48.846]                           master <- get("master", mode = "list", 
[15:32:48.846]                             envir = envir, inherits = FALSE)
[15:32:48.846]                           if (inherits(master, c("SOCKnode", 
[15:32:48.846]                             "SOCK0node"))) {
[15:32:48.846]                             sendCondition <<- function(cond) {
[15:32:48.846]                               data <- list(type = "VALUE", value = cond, 
[15:32:48.846]                                 success = TRUE)
[15:32:48.846]                               parallel_sendData(master, data)
[15:32:48.846]                             }
[15:32:48.846]                             return(sendCondition)
[15:32:48.846]                           }
[15:32:48.846]                         }
[15:32:48.846]                         frame <- frame + 1L
[15:32:48.846]                         envir <- sys.frame(frame)
[15:32:48.846]                       }
[15:32:48.846]                     }
[15:32:48.846]                     sendCondition <<- function(cond) NULL
[15:32:48.846]                   }
[15:32:48.846]                 })
[15:32:48.846]                 withCallingHandlers({
[15:32:48.846]                   {
[15:32:48.846]                     do.call(function(...) {
[15:32:48.846]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.846]                       if (!identical(...future.globals.maxSize.org, 
[15:32:48.846]                         ...future.globals.maxSize)) {
[15:32:48.846]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.846]                         on.exit(options(oopts), add = TRUE)
[15:32:48.846]                       }
[15:32:48.846]                       {
[15:32:48.846]                         lapply(seq_along(...future.elements_ii), 
[15:32:48.846]                           FUN = function(jj) {
[15:32:48.846]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.846]                             ...future.FUN(...future.X_jj, ...)
[15:32:48.846]                           })
[15:32:48.846]                       }
[15:32:48.846]                     }, args = future.call.arguments)
[15:32:48.846]                   }
[15:32:48.846]                 }, immediateCondition = function(cond) {
[15:32:48.846]                   sendCondition <- ...future.makeSendCondition()
[15:32:48.846]                   sendCondition(cond)
[15:32:48.846]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.846]                   {
[15:32:48.846]                     inherits <- base::inherits
[15:32:48.846]                     invokeRestart <- base::invokeRestart
[15:32:48.846]                     is.null <- base::is.null
[15:32:48.846]                     muffled <- FALSE
[15:32:48.846]                     if (inherits(cond, "message")) {
[15:32:48.846]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:48.846]                       if (muffled) 
[15:32:48.846]                         invokeRestart("muffleMessage")
[15:32:48.846]                     }
[15:32:48.846]                     else if (inherits(cond, "warning")) {
[15:32:48.846]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:48.846]                       if (muffled) 
[15:32:48.846]                         invokeRestart("muffleWarning")
[15:32:48.846]                     }
[15:32:48.846]                     else if (inherits(cond, "condition")) {
[15:32:48.846]                       if (!is.null(pattern)) {
[15:32:48.846]                         computeRestarts <- base::computeRestarts
[15:32:48.846]                         grepl <- base::grepl
[15:32:48.846]                         restarts <- computeRestarts(cond)
[15:32:48.846]                         for (restart in restarts) {
[15:32:48.846]                           name <- restart$name
[15:32:48.846]                           if (is.null(name)) 
[15:32:48.846]                             next
[15:32:48.846]                           if (!grepl(pattern, name)) 
[15:32:48.846]                             next
[15:32:48.846]                           invokeRestart(restart)
[15:32:48.846]                           muffled <- TRUE
[15:32:48.846]                           break
[15:32:48.846]                         }
[15:32:48.846]                       }
[15:32:48.846]                     }
[15:32:48.846]                     invisible(muffled)
[15:32:48.846]                   }
[15:32:48.846]                   muffleCondition(cond)
[15:32:48.846]                 })
[15:32:48.846]             }))
[15:32:48.846]             future::FutureResult(value = ...future.value$value, 
[15:32:48.846]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.846]                   ...future.rng), globalenv = if (FALSE) 
[15:32:48.846]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:48.846]                     ...future.globalenv.names))
[15:32:48.846]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:48.846]         }, condition = base::local({
[15:32:48.846]             c <- base::c
[15:32:48.846]             inherits <- base::inherits
[15:32:48.846]             invokeRestart <- base::invokeRestart
[15:32:48.846]             length <- base::length
[15:32:48.846]             list <- base::list
[15:32:48.846]             seq.int <- base::seq.int
[15:32:48.846]             signalCondition <- base::signalCondition
[15:32:48.846]             sys.calls <- base::sys.calls
[15:32:48.846]             `[[` <- base::`[[`
[15:32:48.846]             `+` <- base::`+`
[15:32:48.846]             `<<-` <- base::`<<-`
[15:32:48.846]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:48.846]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:48.846]                   3L)]
[15:32:48.846]             }
[15:32:48.846]             function(cond) {
[15:32:48.846]                 is_error <- inherits(cond, "error")
[15:32:48.846]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:48.846]                   NULL)
[15:32:48.846]                 if (is_error) {
[15:32:48.846]                   sessionInformation <- function() {
[15:32:48.846]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:48.846]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:48.846]                       search = base::search(), system = base::Sys.info())
[15:32:48.846]                   }
[15:32:48.846]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.846]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:48.846]                     cond$call), session = sessionInformation(), 
[15:32:48.846]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:48.846]                   signalCondition(cond)
[15:32:48.846]                 }
[15:32:48.846]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:48.846]                 "immediateCondition"))) {
[15:32:48.846]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:48.846]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.846]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:48.846]                   if (TRUE && !signal) {
[15:32:48.846]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.846]                     {
[15:32:48.846]                       inherits <- base::inherits
[15:32:48.846]                       invokeRestart <- base::invokeRestart
[15:32:48.846]                       is.null <- base::is.null
[15:32:48.846]                       muffled <- FALSE
[15:32:48.846]                       if (inherits(cond, "message")) {
[15:32:48.846]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.846]                         if (muffled) 
[15:32:48.846]                           invokeRestart("muffleMessage")
[15:32:48.846]                       }
[15:32:48.846]                       else if (inherits(cond, "warning")) {
[15:32:48.846]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.846]                         if (muffled) 
[15:32:48.846]                           invokeRestart("muffleWarning")
[15:32:48.846]                       }
[15:32:48.846]                       else if (inherits(cond, "condition")) {
[15:32:48.846]                         if (!is.null(pattern)) {
[15:32:48.846]                           computeRestarts <- base::computeRestarts
[15:32:48.846]                           grepl <- base::grepl
[15:32:48.846]                           restarts <- computeRestarts(cond)
[15:32:48.846]                           for (restart in restarts) {
[15:32:48.846]                             name <- restart$name
[15:32:48.846]                             if (is.null(name)) 
[15:32:48.846]                               next
[15:32:48.846]                             if (!grepl(pattern, name)) 
[15:32:48.846]                               next
[15:32:48.846]                             invokeRestart(restart)
[15:32:48.846]                             muffled <- TRUE
[15:32:48.846]                             break
[15:32:48.846]                           }
[15:32:48.846]                         }
[15:32:48.846]                       }
[15:32:48.846]                       invisible(muffled)
[15:32:48.846]                     }
[15:32:48.846]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.846]                   }
[15:32:48.846]                 }
[15:32:48.846]                 else {
[15:32:48.846]                   if (TRUE) {
[15:32:48.846]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.846]                     {
[15:32:48.846]                       inherits <- base::inherits
[15:32:48.846]                       invokeRestart <- base::invokeRestart
[15:32:48.846]                       is.null <- base::is.null
[15:32:48.846]                       muffled <- FALSE
[15:32:48.846]                       if (inherits(cond, "message")) {
[15:32:48.846]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.846]                         if (muffled) 
[15:32:48.846]                           invokeRestart("muffleMessage")
[15:32:48.846]                       }
[15:32:48.846]                       else if (inherits(cond, "warning")) {
[15:32:48.846]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.846]                         if (muffled) 
[15:32:48.846]                           invokeRestart("muffleWarning")
[15:32:48.846]                       }
[15:32:48.846]                       else if (inherits(cond, "condition")) {
[15:32:48.846]                         if (!is.null(pattern)) {
[15:32:48.846]                           computeRestarts <- base::computeRestarts
[15:32:48.846]                           grepl <- base::grepl
[15:32:48.846]                           restarts <- computeRestarts(cond)
[15:32:48.846]                           for (restart in restarts) {
[15:32:48.846]                             name <- restart$name
[15:32:48.846]                             if (is.null(name)) 
[15:32:48.846]                               next
[15:32:48.846]                             if (!grepl(pattern, name)) 
[15:32:48.846]                               next
[15:32:48.846]                             invokeRestart(restart)
[15:32:48.846]                             muffled <- TRUE
[15:32:48.846]                             break
[15:32:48.846]                           }
[15:32:48.846]                         }
[15:32:48.846]                       }
[15:32:48.846]                       invisible(muffled)
[15:32:48.846]                     }
[15:32:48.846]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.846]                   }
[15:32:48.846]                 }
[15:32:48.846]             }
[15:32:48.846]         }))
[15:32:48.846]     }, error = function(ex) {
[15:32:48.846]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:48.846]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.846]                 ...future.rng), started = ...future.startTime, 
[15:32:48.846]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:48.846]             version = "1.8"), class = "FutureResult")
[15:32:48.846]     }, finally = {
[15:32:48.846]         if (!identical(...future.workdir, getwd())) 
[15:32:48.846]             setwd(...future.workdir)
[15:32:48.846]         {
[15:32:48.846]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:48.846]                 ...future.oldOptions$nwarnings <- NULL
[15:32:48.846]             }
[15:32:48.846]             base::options(...future.oldOptions)
[15:32:48.846]             if (.Platform$OS.type == "windows") {
[15:32:48.846]                 old_names <- names(...future.oldEnvVars)
[15:32:48.846]                 envs <- base::Sys.getenv()
[15:32:48.846]                 names <- names(envs)
[15:32:48.846]                 common <- intersect(names, old_names)
[15:32:48.846]                 added <- setdiff(names, old_names)
[15:32:48.846]                 removed <- setdiff(old_names, names)
[15:32:48.846]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:48.846]                   envs[common]]
[15:32:48.846]                 NAMES <- toupper(changed)
[15:32:48.846]                 args <- list()
[15:32:48.846]                 for (kk in seq_along(NAMES)) {
[15:32:48.846]                   name <- changed[[kk]]
[15:32:48.846]                   NAME <- NAMES[[kk]]
[15:32:48.846]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.846]                     next
[15:32:48.846]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.846]                 }
[15:32:48.846]                 NAMES <- toupper(added)
[15:32:48.846]                 for (kk in seq_along(NAMES)) {
[15:32:48.846]                   name <- added[[kk]]
[15:32:48.846]                   NAME <- NAMES[[kk]]
[15:32:48.846]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.846]                     next
[15:32:48.846]                   args[[name]] <- ""
[15:32:48.846]                 }
[15:32:48.846]                 NAMES <- toupper(removed)
[15:32:48.846]                 for (kk in seq_along(NAMES)) {
[15:32:48.846]                   name <- removed[[kk]]
[15:32:48.846]                   NAME <- NAMES[[kk]]
[15:32:48.846]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.846]                     next
[15:32:48.846]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.846]                 }
[15:32:48.846]                 if (length(args) > 0) 
[15:32:48.846]                   base::do.call(base::Sys.setenv, args = args)
[15:32:48.846]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:48.846]             }
[15:32:48.846]             else {
[15:32:48.846]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:48.846]             }
[15:32:48.846]             {
[15:32:48.846]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:48.846]                   0L) {
[15:32:48.846]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:48.846]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:48.846]                   base::options(opts)
[15:32:48.846]                 }
[15:32:48.846]                 {
[15:32:48.846]                   {
[15:32:48.846]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:48.846]                     NULL
[15:32:48.846]                   }
[15:32:48.846]                   options(future.plan = NULL)
[15:32:48.846]                   if (is.na(NA_character_)) 
[15:32:48.846]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.846]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:48.846]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:48.846]                     .init = FALSE)
[15:32:48.846]                 }
[15:32:48.846]             }
[15:32:48.846]         }
[15:32:48.846]     })
[15:32:48.846]     if (TRUE) {
[15:32:48.846]         base::sink(type = "output", split = FALSE)
[15:32:48.846]         if (TRUE) {
[15:32:48.846]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:48.846]         }
[15:32:48.846]         else {
[15:32:48.846]             ...future.result["stdout"] <- base::list(NULL)
[15:32:48.846]         }
[15:32:48.846]         base::close(...future.stdout)
[15:32:48.846]         ...future.stdout <- NULL
[15:32:48.846]     }
[15:32:48.846]     ...future.result$conditions <- ...future.conditions
[15:32:48.846]     ...future.result$finished <- base::Sys.time()
[15:32:48.846]     ...future.result
[15:32:48.846] }
[15:32:48.852] Exporting 11 global objects (95.02 KiB) to cluster node #1 ...
[15:32:48.852] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:48.852] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:48.853] Exporting 'x_FUN' (2.90 KiB) to cluster node #1 ...
[15:32:48.853] Exporting 'x_FUN' (2.90 KiB) to cluster node #1 ... DONE
[15:32:48.853] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:48.854] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:48.854] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:48.855] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:48.855] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:48.855] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:48.856] Exporting 'dim' (56 bytes) to cluster node #1 ...
[15:32:48.856] Exporting 'dim' (56 bytes) to cluster node #1 ... DONE
[15:32:48.856] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:48.857] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:48.857] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:48.857] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:48.858] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:48.858] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:48.858] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:48.859] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:48.859] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:48.860] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:48.861] Exporting 11 global objects (95.02 KiB) to cluster node #1 ... DONE
[15:32:48.862] MultisessionFuture started
[15:32:48.862] - Launch lazy future ... done
[15:32:48.862] run() for 'MultisessionFuture' ... done
[15:32:48.863] Created future:
[15:32:48.886] receiveMessageFromWorker() for ClusterFuture ...
[15:32:48.886] - Validating connection of MultisessionFuture
[15:32:48.886] - received message: FutureResult
[15:32:48.887] - Received FutureResult
[15:32:48.887] - Erased future from FutureRegistry
[15:32:48.887] result() for ClusterFuture ...
[15:32:48.887] - result already collected: FutureResult
[15:32:48.887] result() for ClusterFuture ... done
[15:32:48.888] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:48.863] MultisessionFuture:
[15:32:48.863] Label: 'future_vapply-2'
[15:32:48.863] Expression:
[15:32:48.863] {
[15:32:48.863]     do.call(function(...) {
[15:32:48.863]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.863]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.863]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.863]             on.exit(options(oopts), add = TRUE)
[15:32:48.863]         }
[15:32:48.863]         {
[15:32:48.863]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.863]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.863]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.863]             })
[15:32:48.863]         }
[15:32:48.863]     }, args = future.call.arguments)
[15:32:48.863] }
[15:32:48.863] Lazy evaluation: FALSE
[15:32:48.863] Asynchronous evaluation: TRUE
[15:32:48.863] Local evaluation: TRUE
[15:32:48.863] Environment: R_GlobalEnv
[15:32:48.863] Capture standard output: TRUE
[15:32:48.863] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:48.863] Globals: 11 objects totaling 95.30 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 2.90 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:48.863] Packages: 1 packages ('future.apply')
[15:32:48.863] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:48.863] Resolved: TRUE
[15:32:48.863] Value: <not collected>
[15:32:48.863] Conditions captured: <none>
[15:32:48.863] Early signaling: FALSE
[15:32:48.863] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:48.863] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.888] Chunk #2 of 2 ... DONE
[15:32:48.889] Launching 2 futures (chunks) ... DONE
[15:32:48.889] Resolving 2 futures (chunks) ...
[15:32:48.889] resolve() on list ...
[15:32:48.889]  recursive: 0
[15:32:48.890]  length: 2
[15:32:48.890] 
[15:32:48.890] Future #1
[15:32:48.890] result() for ClusterFuture ...
[15:32:48.891] - result already collected: FutureResult
[15:32:48.891] result() for ClusterFuture ... done
[15:32:48.891] result() for ClusterFuture ...
[15:32:48.891] - result already collected: FutureResult
[15:32:48.892] result() for ClusterFuture ... done
[15:32:48.892] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:48.892] - nx: 2
[15:32:48.892] - relay: TRUE
[15:32:48.893] - stdout: TRUE
[15:32:48.893] - signal: TRUE
[15:32:48.893] - resignal: FALSE
[15:32:48.893] - force: TRUE
[15:32:48.894] - relayed: [n=2] FALSE, FALSE
[15:32:48.894] - queued futures: [n=2] FALSE, FALSE
[15:32:48.894]  - until=1
[15:32:48.894]  - relaying element #1
[15:32:48.894] result() for ClusterFuture ...
[15:32:48.895] - result already collected: FutureResult
[15:32:48.895] result() for ClusterFuture ... done
[15:32:48.895] result() for ClusterFuture ...
[15:32:48.895] - result already collected: FutureResult
[15:32:48.895] result() for ClusterFuture ... done
[15:32:48.895] result() for ClusterFuture ...
[15:32:48.896] - result already collected: FutureResult
[15:32:48.896] result() for ClusterFuture ... done
[15:32:48.896] result() for ClusterFuture ...
[15:32:48.896] - result already collected: FutureResult
[15:32:48.896] result() for ClusterFuture ... done
[15:32:48.896] - relayed: [n=2] TRUE, FALSE
[15:32:48.897] - queued futures: [n=2] TRUE, FALSE
[15:32:48.897] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:48.897]  length: 1 (resolved future 1)
[15:32:48.897] Future #2
[15:32:48.897] result() for ClusterFuture ...
[15:32:48.898] - result already collected: FutureResult
[15:32:48.898] result() for ClusterFuture ... done
[15:32:48.898] result() for ClusterFuture ...
[15:32:48.898] - result already collected: FutureResult
[15:32:48.898] result() for ClusterFuture ... done
[15:32:48.898] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:48.899] - nx: 2
[15:32:48.899] - relay: TRUE
[15:32:48.899] - stdout: TRUE
[15:32:48.899] - signal: TRUE
[15:32:48.899] - resignal: FALSE
[15:32:48.899] - force: TRUE
[15:32:48.900] - relayed: [n=2] TRUE, FALSE
[15:32:48.900] - queued futures: [n=2] TRUE, FALSE
[15:32:48.900]  - until=2
[15:32:48.900]  - relaying element #2
[15:32:48.900] result() for ClusterFuture ...
[15:32:48.900] - result already collected: FutureResult
[15:32:48.901] result() for ClusterFuture ... done
[15:32:48.901] result() for ClusterFuture ...
[15:32:48.901] - result already collected: FutureResult
[15:32:48.901] result() for ClusterFuture ... done
[15:32:48.901] result() for ClusterFuture ...
[15:32:48.901] - result already collected: FutureResult
[15:32:48.902] result() for ClusterFuture ... done
[15:32:48.902] result() for ClusterFuture ...
[15:32:48.902] - result already collected: FutureResult
[15:32:48.902] result() for ClusterFuture ... done
[15:32:48.902] - relayed: [n=2] TRUE, TRUE
[15:32:48.902] - queued futures: [n=2] TRUE, TRUE
[15:32:48.903] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:48.903]  length: 0 (resolved future 2)
[15:32:48.903] Relaying remaining futures
[15:32:48.903] signalConditionsASAP(NULL, pos=0) ...
[15:32:48.903] - nx: 2
[15:32:48.903] - relay: TRUE
[15:32:48.904] - stdout: TRUE
[15:32:48.904] - signal: TRUE
[15:32:48.904] - resignal: FALSE
[15:32:48.904] - force: TRUE
[15:32:48.904] - relayed: [n=2] TRUE, TRUE
[15:32:48.904] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:48.905] - relayed: [n=2] TRUE, TRUE
[15:32:48.905] - queued futures: [n=2] TRUE, TRUE
[15:32:48.905] signalConditionsASAP(NULL, pos=0) ... done
[15:32:48.905] resolve() on list ... DONE
[15:32:48.905] result() for ClusterFuture ...
[15:32:48.906] - result already collected: FutureResult
[15:32:48.906] result() for ClusterFuture ... done
[15:32:48.906] result() for ClusterFuture ...
[15:32:48.906] - result already collected: FutureResult
[15:32:48.907] result() for ClusterFuture ... done
[15:32:48.907] result() for ClusterFuture ...
[15:32:48.907] - result already collected: FutureResult
[15:32:48.907] result() for ClusterFuture ... done
[15:32:48.908] result() for ClusterFuture ...
[15:32:48.908] - result already collected: FutureResult
[15:32:48.908] result() for ClusterFuture ... done
[15:32:48.909]  - Number of value chunks collected: 2
[15:32:48.909] Resolving 2 futures (chunks) ... DONE
[15:32:48.909] Reducing values from 2 chunks ...
[15:32:48.909]  - Number of values collected after concatenation: 10
[15:32:48.910]  - Number of values expected: 10
[15:32:48.910] Reducing values from 2 chunks ... DONE
[15:32:48.910] future_lapply() ... DONE
 int [1:2, 1:2, 1:10] 1 1 1 1 2 2 2 2 3 3 ...
 num [1:2, 1:2, 1:10] 1 1 1 1 2 2 2 2 3 3 ...
 - attr(*, "dimnames")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:2] "A" "B"
  ..$ : NULL
[15:32:48.914] future_lapply() ...
[15:32:48.920] Number of chunks: 2
[15:32:48.920] getGlobalsAndPackagesXApply() ...
[15:32:48.920]  - future.globals: TRUE
[15:32:48.920] getGlobalsAndPackages() ...
[15:32:48.920] Searching for globals...
[15:32:48.926] - globals found: [19] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'matrix', 'list', 'c'
[15:32:48.926] Searching for globals ... DONE
[15:32:48.926] Resolving globals: FALSE
[15:32:48.927] The total size of the 7 globals is 103.08 KiB (105552 bytes)
[15:32:48.928] The total size of the 7 globals exported for future expression ('FUN()') is 103.08 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:48.928] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:48.928] - packages: [1] 'future.apply'
[15:32:48.928] getGlobalsAndPackages() ... DONE
[15:32:48.929]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:48.929]  - needed namespaces: [n=1] 'future.apply'
[15:32:48.929] Finding globals ... DONE
[15:32:48.929]  - use_args: TRUE
[15:32:48.929]  - Getting '...' globals ...
[15:32:48.930] resolve() on list ...
[15:32:48.930]  recursive: 0
[15:32:48.930]  length: 1
[15:32:48.930]  elements: '...'
[15:32:48.931]  length: 0 (resolved future 1)
[15:32:48.931] resolve() on list ... DONE
[15:32:48.931]    - '...' content: [n=0] 
[15:32:48.931] List of 1
[15:32:48.931]  $ ...: list()
[15:32:48.931]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:48.931]  - attr(*, "where")=List of 1
[15:32:48.931]   ..$ ...:<environment: 0x0000022d40d47b20> 
[15:32:48.931]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:48.931]  - attr(*, "resolved")= logi TRUE
[15:32:48.931]  - attr(*, "total_size")= num NA
[15:32:48.934]  - Getting '...' globals ... DONE
[15:32:48.935] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:48.935] List of 8
[15:32:48.935]  $ ...future.FUN:function (x, ...)  
[15:32:48.935]  $ x_FUN        :function (x)  
[15:32:48.935]  $ times        : int 4
[15:32:48.935]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:48.935]  $ stop_if_not  :function (...)  
[15:32:48.935]  $ dim          : int [1:2] 2 2
[15:32:48.935]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:48.935]  $ ...          : list()
[15:32:48.935]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:48.935]  - attr(*, "where")=List of 8
[15:32:48.935]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:48.935]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:48.935]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:48.935]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:48.935]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:48.935]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:48.935]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:48.935]   ..$ ...          :<environment: 0x0000022d40d47b20> 
[15:32:48.935]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:48.935]  - attr(*, "resolved")= logi FALSE
[15:32:48.935]  - attr(*, "total_size")= num 105552
[15:32:48.942] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:48.942] getGlobalsAndPackagesXApply() ... DONE
[15:32:48.942] Number of futures (= number of chunks): 2
[15:32:48.943] Launching 2 futures (chunks) ...
[15:32:48.943] Chunk #1 of 2 ...
[15:32:48.943]  - Finding globals in 'X' for chunk #1 ...
[15:32:48.943] getGlobalsAndPackages() ...
[15:32:48.943] Searching for globals...
[15:32:48.944] 
[15:32:48.944] Searching for globals ... DONE
[15:32:48.944] - globals: [0] <none>
[15:32:48.944] getGlobalsAndPackages() ... DONE
[15:32:48.944]    + additional globals found: [n=0] 
[15:32:48.945]    + additional namespaces needed: [n=0] 
[15:32:48.945]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:48.945]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:48.945]  - seeds: <none>
[15:32:48.945]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.945] getGlobalsAndPackages() ...
[15:32:48.946] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.946] Resolving globals: FALSE
[15:32:48.946] Tweak future expression to call with '...' arguments ...
[15:32:48.946] {
[15:32:48.946]     do.call(function(...) {
[15:32:48.946]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.946]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.946]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.946]             on.exit(options(oopts), add = TRUE)
[15:32:48.946]         }
[15:32:48.946]         {
[15:32:48.946]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.946]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.946]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.946]             })
[15:32:48.946]         }
[15:32:48.946]     }, args = future.call.arguments)
[15:32:48.946] }
[15:32:48.947] Tweak future expression to call with '...' arguments ... DONE
[15:32:48.948] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:48.948] - packages: [1] 'future.apply'
[15:32:48.949] getGlobalsAndPackages() ... DONE
[15:32:48.949] run() for 'Future' ...
[15:32:48.949] - state: 'created'
[15:32:48.949] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:48.964] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:48.964] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:48.965]   - Field: 'node'
[15:32:48.965]   - Field: 'label'
[15:32:48.965]   - Field: 'local'
[15:32:48.965]   - Field: 'owner'
[15:32:48.965]   - Field: 'envir'
[15:32:48.966]   - Field: 'workers'
[15:32:48.966]   - Field: 'packages'
[15:32:48.966]   - Field: 'gc'
[15:32:48.966]   - Field: 'conditions'
[15:32:48.966]   - Field: 'persistent'
[15:32:48.967]   - Field: 'expr'
[15:32:48.967]   - Field: 'uuid'
[15:32:48.967]   - Field: 'seed'
[15:32:48.967]   - Field: 'version'
[15:32:48.967]   - Field: 'result'
[15:32:48.968]   - Field: 'asynchronous'
[15:32:48.968]   - Field: 'calls'
[15:32:48.968]   - Field: 'globals'
[15:32:48.968]   - Field: 'stdout'
[15:32:48.968]   - Field: 'earlySignal'
[15:32:48.969]   - Field: 'lazy'
[15:32:48.969]   - Field: 'state'
[15:32:48.969] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:48.970] - Launch lazy future ...
[15:32:48.970] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:48.971] Packages needed by future strategies (n = 0): <none>
[15:32:48.972] {
[15:32:48.972]     {
[15:32:48.972]         {
[15:32:48.972]             ...future.startTime <- base::Sys.time()
[15:32:48.972]             {
[15:32:48.972]                 {
[15:32:48.972]                   {
[15:32:48.972]                     {
[15:32:48.972]                       {
[15:32:48.972]                         base::local({
[15:32:48.972]                           has_future <- base::requireNamespace("future", 
[15:32:48.972]                             quietly = TRUE)
[15:32:48.972]                           if (has_future) {
[15:32:48.972]                             ns <- base::getNamespace("future")
[15:32:48.972]                             version <- ns[[".package"]][["version"]]
[15:32:48.972]                             if (is.null(version)) 
[15:32:48.972]                               version <- utils::packageVersion("future")
[15:32:48.972]                           }
[15:32:48.972]                           else {
[15:32:48.972]                             version <- NULL
[15:32:48.972]                           }
[15:32:48.972]                           if (!has_future || version < "1.8.0") {
[15:32:48.972]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:48.972]                               "", base::R.version$version.string), 
[15:32:48.972]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:48.972]                                 base::R.version$platform, 8 * 
[15:32:48.972]                                   base::.Machine$sizeof.pointer), 
[15:32:48.972]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:48.972]                                 "release", "version")], collapse = " "), 
[15:32:48.972]                               hostname = base::Sys.info()[["nodename"]])
[15:32:48.972]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:48.972]                               info)
[15:32:48.972]                             info <- base::paste(info, collapse = "; ")
[15:32:48.972]                             if (!has_future) {
[15:32:48.972]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:48.972]                                 info)
[15:32:48.972]                             }
[15:32:48.972]                             else {
[15:32:48.972]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:48.972]                                 info, version)
[15:32:48.972]                             }
[15:32:48.972]                             base::stop(msg)
[15:32:48.972]                           }
[15:32:48.972]                         })
[15:32:48.972]                       }
[15:32:48.972]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:48.972]                       base::options(mc.cores = 1L)
[15:32:48.972]                     }
[15:32:48.972]                     base::local({
[15:32:48.972]                       for (pkg in "future.apply") {
[15:32:48.972]                         base::loadNamespace(pkg)
[15:32:48.972]                         base::library(pkg, character.only = TRUE)
[15:32:48.972]                       }
[15:32:48.972]                     })
[15:32:48.972]                   }
[15:32:48.972]                   ...future.strategy.old <- future::plan("list")
[15:32:48.972]                   options(future.plan = NULL)
[15:32:48.972]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.972]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:48.972]                 }
[15:32:48.972]                 ...future.workdir <- getwd()
[15:32:48.972]             }
[15:32:48.972]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:48.972]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:48.972]         }
[15:32:48.972]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:48.972]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:48.972]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:48.972]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:48.972]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:48.972]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:48.972]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:48.972]             base::names(...future.oldOptions))
[15:32:48.972]     }
[15:32:48.972]     if (FALSE) {
[15:32:48.972]     }
[15:32:48.972]     else {
[15:32:48.972]         if (TRUE) {
[15:32:48.972]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:48.972]                 open = "w")
[15:32:48.972]         }
[15:32:48.972]         else {
[15:32:48.972]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:48.972]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:48.972]         }
[15:32:48.972]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:48.972]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:48.972]             base::sink(type = "output", split = FALSE)
[15:32:48.972]             base::close(...future.stdout)
[15:32:48.972]         }, add = TRUE)
[15:32:48.972]     }
[15:32:48.972]     ...future.frame <- base::sys.nframe()
[15:32:48.972]     ...future.conditions <- base::list()
[15:32:48.972]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:48.972]     if (FALSE) {
[15:32:48.972]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:48.972]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:48.972]     }
[15:32:48.972]     ...future.result <- base::tryCatch({
[15:32:48.972]         base::withCallingHandlers({
[15:32:48.972]             ...future.value <- base::withVisible(base::local({
[15:32:48.972]                 ...future.makeSendCondition <- base::local({
[15:32:48.972]                   sendCondition <- NULL
[15:32:48.972]                   function(frame = 1L) {
[15:32:48.972]                     if (is.function(sendCondition)) 
[15:32:48.972]                       return(sendCondition)
[15:32:48.972]                     ns <- getNamespace("parallel")
[15:32:48.972]                     if (exists("sendData", mode = "function", 
[15:32:48.972]                       envir = ns)) {
[15:32:48.972]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:48.972]                         envir = ns)
[15:32:48.972]                       envir <- sys.frame(frame)
[15:32:48.972]                       master <- NULL
[15:32:48.972]                       while (!identical(envir, .GlobalEnv) && 
[15:32:48.972]                         !identical(envir, emptyenv())) {
[15:32:48.972]                         if (exists("master", mode = "list", envir = envir, 
[15:32:48.972]                           inherits = FALSE)) {
[15:32:48.972]                           master <- get("master", mode = "list", 
[15:32:48.972]                             envir = envir, inherits = FALSE)
[15:32:48.972]                           if (inherits(master, c("SOCKnode", 
[15:32:48.972]                             "SOCK0node"))) {
[15:32:48.972]                             sendCondition <<- function(cond) {
[15:32:48.972]                               data <- list(type = "VALUE", value = cond, 
[15:32:48.972]                                 success = TRUE)
[15:32:48.972]                               parallel_sendData(master, data)
[15:32:48.972]                             }
[15:32:48.972]                             return(sendCondition)
[15:32:48.972]                           }
[15:32:48.972]                         }
[15:32:48.972]                         frame <- frame + 1L
[15:32:48.972]                         envir <- sys.frame(frame)
[15:32:48.972]                       }
[15:32:48.972]                     }
[15:32:48.972]                     sendCondition <<- function(cond) NULL
[15:32:48.972]                   }
[15:32:48.972]                 })
[15:32:48.972]                 withCallingHandlers({
[15:32:48.972]                   {
[15:32:48.972]                     do.call(function(...) {
[15:32:48.972]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.972]                       if (!identical(...future.globals.maxSize.org, 
[15:32:48.972]                         ...future.globals.maxSize)) {
[15:32:48.972]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.972]                         on.exit(options(oopts), add = TRUE)
[15:32:48.972]                       }
[15:32:48.972]                       {
[15:32:48.972]                         lapply(seq_along(...future.elements_ii), 
[15:32:48.972]                           FUN = function(jj) {
[15:32:48.972]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.972]                             ...future.FUN(...future.X_jj, ...)
[15:32:48.972]                           })
[15:32:48.972]                       }
[15:32:48.972]                     }, args = future.call.arguments)
[15:32:48.972]                   }
[15:32:48.972]                 }, immediateCondition = function(cond) {
[15:32:48.972]                   sendCondition <- ...future.makeSendCondition()
[15:32:48.972]                   sendCondition(cond)
[15:32:48.972]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.972]                   {
[15:32:48.972]                     inherits <- base::inherits
[15:32:48.972]                     invokeRestart <- base::invokeRestart
[15:32:48.972]                     is.null <- base::is.null
[15:32:48.972]                     muffled <- FALSE
[15:32:48.972]                     if (inherits(cond, "message")) {
[15:32:48.972]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:48.972]                       if (muffled) 
[15:32:48.972]                         invokeRestart("muffleMessage")
[15:32:48.972]                     }
[15:32:48.972]                     else if (inherits(cond, "warning")) {
[15:32:48.972]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:48.972]                       if (muffled) 
[15:32:48.972]                         invokeRestart("muffleWarning")
[15:32:48.972]                     }
[15:32:48.972]                     else if (inherits(cond, "condition")) {
[15:32:48.972]                       if (!is.null(pattern)) {
[15:32:48.972]                         computeRestarts <- base::computeRestarts
[15:32:48.972]                         grepl <- base::grepl
[15:32:48.972]                         restarts <- computeRestarts(cond)
[15:32:48.972]                         for (restart in restarts) {
[15:32:48.972]                           name <- restart$name
[15:32:48.972]                           if (is.null(name)) 
[15:32:48.972]                             next
[15:32:48.972]                           if (!grepl(pattern, name)) 
[15:32:48.972]                             next
[15:32:48.972]                           invokeRestart(restart)
[15:32:48.972]                           muffled <- TRUE
[15:32:48.972]                           break
[15:32:48.972]                         }
[15:32:48.972]                       }
[15:32:48.972]                     }
[15:32:48.972]                     invisible(muffled)
[15:32:48.972]                   }
[15:32:48.972]                   muffleCondition(cond)
[15:32:48.972]                 })
[15:32:48.972]             }))
[15:32:48.972]             future::FutureResult(value = ...future.value$value, 
[15:32:48.972]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.972]                   ...future.rng), globalenv = if (FALSE) 
[15:32:48.972]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:48.972]                     ...future.globalenv.names))
[15:32:48.972]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:48.972]         }, condition = base::local({
[15:32:48.972]             c <- base::c
[15:32:48.972]             inherits <- base::inherits
[15:32:48.972]             invokeRestart <- base::invokeRestart
[15:32:48.972]             length <- base::length
[15:32:48.972]             list <- base::list
[15:32:48.972]             seq.int <- base::seq.int
[15:32:48.972]             signalCondition <- base::signalCondition
[15:32:48.972]             sys.calls <- base::sys.calls
[15:32:48.972]             `[[` <- base::`[[`
[15:32:48.972]             `+` <- base::`+`
[15:32:48.972]             `<<-` <- base::`<<-`
[15:32:48.972]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:48.972]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:48.972]                   3L)]
[15:32:48.972]             }
[15:32:48.972]             function(cond) {
[15:32:48.972]                 is_error <- inherits(cond, "error")
[15:32:48.972]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:48.972]                   NULL)
[15:32:48.972]                 if (is_error) {
[15:32:48.972]                   sessionInformation <- function() {
[15:32:48.972]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:48.972]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:48.972]                       search = base::search(), system = base::Sys.info())
[15:32:48.972]                   }
[15:32:48.972]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.972]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:48.972]                     cond$call), session = sessionInformation(), 
[15:32:48.972]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:48.972]                   signalCondition(cond)
[15:32:48.972]                 }
[15:32:48.972]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:48.972]                 "immediateCondition"))) {
[15:32:48.972]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:48.972]                   ...future.conditions[[length(...future.conditions) + 
[15:32:48.972]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:48.972]                   if (TRUE && !signal) {
[15:32:48.972]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.972]                     {
[15:32:48.972]                       inherits <- base::inherits
[15:32:48.972]                       invokeRestart <- base::invokeRestart
[15:32:48.972]                       is.null <- base::is.null
[15:32:48.972]                       muffled <- FALSE
[15:32:48.972]                       if (inherits(cond, "message")) {
[15:32:48.972]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.972]                         if (muffled) 
[15:32:48.972]                           invokeRestart("muffleMessage")
[15:32:48.972]                       }
[15:32:48.972]                       else if (inherits(cond, "warning")) {
[15:32:48.972]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.972]                         if (muffled) 
[15:32:48.972]                           invokeRestart("muffleWarning")
[15:32:48.972]                       }
[15:32:48.972]                       else if (inherits(cond, "condition")) {
[15:32:48.972]                         if (!is.null(pattern)) {
[15:32:48.972]                           computeRestarts <- base::computeRestarts
[15:32:48.972]                           grepl <- base::grepl
[15:32:48.972]                           restarts <- computeRestarts(cond)
[15:32:48.972]                           for (restart in restarts) {
[15:32:48.972]                             name <- restart$name
[15:32:48.972]                             if (is.null(name)) 
[15:32:48.972]                               next
[15:32:48.972]                             if (!grepl(pattern, name)) 
[15:32:48.972]                               next
[15:32:48.972]                             invokeRestart(restart)
[15:32:48.972]                             muffled <- TRUE
[15:32:48.972]                             break
[15:32:48.972]                           }
[15:32:48.972]                         }
[15:32:48.972]                       }
[15:32:48.972]                       invisible(muffled)
[15:32:48.972]                     }
[15:32:48.972]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.972]                   }
[15:32:48.972]                 }
[15:32:48.972]                 else {
[15:32:48.972]                   if (TRUE) {
[15:32:48.972]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:48.972]                     {
[15:32:48.972]                       inherits <- base::inherits
[15:32:48.972]                       invokeRestart <- base::invokeRestart
[15:32:48.972]                       is.null <- base::is.null
[15:32:48.972]                       muffled <- FALSE
[15:32:48.972]                       if (inherits(cond, "message")) {
[15:32:48.972]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:48.972]                         if (muffled) 
[15:32:48.972]                           invokeRestart("muffleMessage")
[15:32:48.972]                       }
[15:32:48.972]                       else if (inherits(cond, "warning")) {
[15:32:48.972]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:48.972]                         if (muffled) 
[15:32:48.972]                           invokeRestart("muffleWarning")
[15:32:48.972]                       }
[15:32:48.972]                       else if (inherits(cond, "condition")) {
[15:32:48.972]                         if (!is.null(pattern)) {
[15:32:48.972]                           computeRestarts <- base::computeRestarts
[15:32:48.972]                           grepl <- base::grepl
[15:32:48.972]                           restarts <- computeRestarts(cond)
[15:32:48.972]                           for (restart in restarts) {
[15:32:48.972]                             name <- restart$name
[15:32:48.972]                             if (is.null(name)) 
[15:32:48.972]                               next
[15:32:48.972]                             if (!grepl(pattern, name)) 
[15:32:48.972]                               next
[15:32:48.972]                             invokeRestart(restart)
[15:32:48.972]                             muffled <- TRUE
[15:32:48.972]                             break
[15:32:48.972]                           }
[15:32:48.972]                         }
[15:32:48.972]                       }
[15:32:48.972]                       invisible(muffled)
[15:32:48.972]                     }
[15:32:48.972]                     muffleCondition(cond, pattern = "^muffle")
[15:32:48.972]                   }
[15:32:48.972]                 }
[15:32:48.972]             }
[15:32:48.972]         }))
[15:32:48.972]     }, error = function(ex) {
[15:32:48.972]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:48.972]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:48.972]                 ...future.rng), started = ...future.startTime, 
[15:32:48.972]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:48.972]             version = "1.8"), class = "FutureResult")
[15:32:48.972]     }, finally = {
[15:32:48.972]         if (!identical(...future.workdir, getwd())) 
[15:32:48.972]             setwd(...future.workdir)
[15:32:48.972]         {
[15:32:48.972]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:48.972]                 ...future.oldOptions$nwarnings <- NULL
[15:32:48.972]             }
[15:32:48.972]             base::options(...future.oldOptions)
[15:32:48.972]             if (.Platform$OS.type == "windows") {
[15:32:48.972]                 old_names <- names(...future.oldEnvVars)
[15:32:48.972]                 envs <- base::Sys.getenv()
[15:32:48.972]                 names <- names(envs)
[15:32:48.972]                 common <- intersect(names, old_names)
[15:32:48.972]                 added <- setdiff(names, old_names)
[15:32:48.972]                 removed <- setdiff(old_names, names)
[15:32:48.972]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:48.972]                   envs[common]]
[15:32:48.972]                 NAMES <- toupper(changed)
[15:32:48.972]                 args <- list()
[15:32:48.972]                 for (kk in seq_along(NAMES)) {
[15:32:48.972]                   name <- changed[[kk]]
[15:32:48.972]                   NAME <- NAMES[[kk]]
[15:32:48.972]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.972]                     next
[15:32:48.972]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.972]                 }
[15:32:48.972]                 NAMES <- toupper(added)
[15:32:48.972]                 for (kk in seq_along(NAMES)) {
[15:32:48.972]                   name <- added[[kk]]
[15:32:48.972]                   NAME <- NAMES[[kk]]
[15:32:48.972]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.972]                     next
[15:32:48.972]                   args[[name]] <- ""
[15:32:48.972]                 }
[15:32:48.972]                 NAMES <- toupper(removed)
[15:32:48.972]                 for (kk in seq_along(NAMES)) {
[15:32:48.972]                   name <- removed[[kk]]
[15:32:48.972]                   NAME <- NAMES[[kk]]
[15:32:48.972]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:48.972]                     next
[15:32:48.972]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:48.972]                 }
[15:32:48.972]                 if (length(args) > 0) 
[15:32:48.972]                   base::do.call(base::Sys.setenv, args = args)
[15:32:48.972]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:48.972]             }
[15:32:48.972]             else {
[15:32:48.972]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:48.972]             }
[15:32:48.972]             {
[15:32:48.972]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:48.972]                   0L) {
[15:32:48.972]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:48.972]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:48.972]                   base::options(opts)
[15:32:48.972]                 }
[15:32:48.972]                 {
[15:32:48.972]                   {
[15:32:48.972]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:48.972]                     NULL
[15:32:48.972]                   }
[15:32:48.972]                   options(future.plan = NULL)
[15:32:48.972]                   if (is.na(NA_character_)) 
[15:32:48.972]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:48.972]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:48.972]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:48.972]                     .init = FALSE)
[15:32:48.972]                 }
[15:32:48.972]             }
[15:32:48.972]         }
[15:32:48.972]     })
[15:32:48.972]     if (TRUE) {
[15:32:48.972]         base::sink(type = "output", split = FALSE)
[15:32:48.972]         if (TRUE) {
[15:32:48.972]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:48.972]         }
[15:32:48.972]         else {
[15:32:48.972]             ...future.result["stdout"] <- base::list(NULL)
[15:32:48.972]         }
[15:32:48.972]         base::close(...future.stdout)
[15:32:48.972]         ...future.stdout <- NULL
[15:32:48.972]     }
[15:32:48.972]     ...future.result$conditions <- ...future.conditions
[15:32:48.972]     ...future.result$finished <- base::Sys.time()
[15:32:48.972]     ...future.result
[15:32:48.972] }
[15:32:48.978] Exporting 11 global objects (103.08 KiB) to cluster node #1 ...
[15:32:48.978] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:48.979] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:48.979] Exporting 'x_FUN' (10.95 KiB) to cluster node #1 ...
[15:32:48.979] Exporting 'x_FUN' (10.95 KiB) to cluster node #1 ... DONE
[15:32:48.980] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:48.980] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:48.980] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:48.981] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:48.981] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:48.982] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:48.982] Exporting 'dim' (56 bytes) to cluster node #1 ...
[15:32:48.982] Exporting 'dim' (56 bytes) to cluster node #1 ... DONE
[15:32:48.983] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:48.983] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:48.983] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:48.984] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:48.984] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:48.985] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:48.986] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:48.986] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:48.987] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:48.987] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:48.988] Exporting 11 global objects (103.08 KiB) to cluster node #1 ... DONE
[15:32:48.989] MultisessionFuture started
[15:32:48.989] - Launch lazy future ... done
[15:32:48.989] run() for 'MultisessionFuture' ... done
[15:32:48.989] Created future:
[15:32:49.017] receiveMessageFromWorker() for ClusterFuture ...
[15:32:49.018] - Validating connection of MultisessionFuture
[15:32:49.018] - received message: FutureResult
[15:32:49.019] - Received FutureResult
[15:32:49.019] - Erased future from FutureRegistry
[15:32:49.019] result() for ClusterFuture ...
[15:32:49.019] - result already collected: FutureResult
[15:32:49.023] result() for ClusterFuture ... done
[15:32:49.023] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:48.990] MultisessionFuture:
[15:32:48.990] Label: 'future_vapply-1'
[15:32:48.990] Expression:
[15:32:48.990] {
[15:32:48.990]     do.call(function(...) {
[15:32:48.990]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:48.990]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:48.990]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:48.990]             on.exit(options(oopts), add = TRUE)
[15:32:48.990]         }
[15:32:48.990]         {
[15:32:48.990]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:48.990]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:48.990]                 ...future.FUN(...future.X_jj, ...)
[15:32:48.990]             })
[15:32:48.990]         }
[15:32:48.990]     }, args = future.call.arguments)
[15:32:48.990] }
[15:32:48.990] Lazy evaluation: FALSE
[15:32:48.990] Asynchronous evaluation: TRUE
[15:32:48.990] Local evaluation: TRUE
[15:32:48.990] Environment: R_GlobalEnv
[15:32:48.990] Capture standard output: TRUE
[15:32:48.990] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:48.990] Globals: 11 objects totaling 103.35 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 10.95 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:48.990] Packages: 1 packages ('future.apply')
[15:32:48.990] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:48.990] Resolved: TRUE
[15:32:48.990] Value: <not collected>
[15:32:48.990] Conditions captured: <none>
[15:32:48.990] Early signaling: FALSE
[15:32:48.990] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:48.990] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.024] Chunk #1 of 2 ... DONE
[15:32:49.024] Chunk #2 of 2 ...
[15:32:49.025]  - Finding globals in 'X' for chunk #2 ...
[15:32:49.025] getGlobalsAndPackages() ...
[15:32:49.025] Searching for globals...
[15:32:49.026] 
[15:32:49.026] Searching for globals ... DONE
[15:32:49.026] - globals: [0] <none>
[15:32:49.027] getGlobalsAndPackages() ... DONE
[15:32:49.027]    + additional globals found: [n=0] 
[15:32:49.027]    + additional namespaces needed: [n=0] 
[15:32:49.027]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:49.028]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:49.028]  - seeds: <none>
[15:32:49.028]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.029] getGlobalsAndPackages() ...
[15:32:49.029] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.029] Resolving globals: FALSE
[15:32:49.029] Tweak future expression to call with '...' arguments ...
[15:32:49.030] {
[15:32:49.030]     do.call(function(...) {
[15:32:49.030]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.030]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.030]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.030]             on.exit(options(oopts), add = TRUE)
[15:32:49.030]         }
[15:32:49.030]         {
[15:32:49.030]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.030]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.030]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.030]             })
[15:32:49.030]         }
[15:32:49.030]     }, args = future.call.arguments)
[15:32:49.030] }
[15:32:49.030] Tweak future expression to call with '...' arguments ... DONE
[15:32:49.031] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.032] - packages: [1] 'future.apply'
[15:32:49.032] getGlobalsAndPackages() ... DONE
[15:32:49.032] run() for 'Future' ...
[15:32:49.032] - state: 'created'
[15:32:49.033] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:49.048] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.048] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:49.048]   - Field: 'node'
[15:32:49.048]   - Field: 'label'
[15:32:49.049]   - Field: 'local'
[15:32:49.049]   - Field: 'owner'
[15:32:49.049]   - Field: 'envir'
[15:32:49.049]   - Field: 'workers'
[15:32:49.049]   - Field: 'packages'
[15:32:49.050]   - Field: 'gc'
[15:32:49.050]   - Field: 'conditions'
[15:32:49.050]   - Field: 'persistent'
[15:32:49.050]   - Field: 'expr'
[15:32:49.050]   - Field: 'uuid'
[15:32:49.051]   - Field: 'seed'
[15:32:49.051]   - Field: 'version'
[15:32:49.051]   - Field: 'result'
[15:32:49.051]   - Field: 'asynchronous'
[15:32:49.051]   - Field: 'calls'
[15:32:49.052]   - Field: 'globals'
[15:32:49.052]   - Field: 'stdout'
[15:32:49.052]   - Field: 'earlySignal'
[15:32:49.053]   - Field: 'lazy'
[15:32:49.053]   - Field: 'state'
[15:32:49.053] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:49.053] - Launch lazy future ...
[15:32:49.054] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:49.054] Packages needed by future strategies (n = 0): <none>
[15:32:49.055] {
[15:32:49.055]     {
[15:32:49.055]         {
[15:32:49.055]             ...future.startTime <- base::Sys.time()
[15:32:49.055]             {
[15:32:49.055]                 {
[15:32:49.055]                   {
[15:32:49.055]                     {
[15:32:49.055]                       {
[15:32:49.055]                         base::local({
[15:32:49.055]                           has_future <- base::requireNamespace("future", 
[15:32:49.055]                             quietly = TRUE)
[15:32:49.055]                           if (has_future) {
[15:32:49.055]                             ns <- base::getNamespace("future")
[15:32:49.055]                             version <- ns[[".package"]][["version"]]
[15:32:49.055]                             if (is.null(version)) 
[15:32:49.055]                               version <- utils::packageVersion("future")
[15:32:49.055]                           }
[15:32:49.055]                           else {
[15:32:49.055]                             version <- NULL
[15:32:49.055]                           }
[15:32:49.055]                           if (!has_future || version < "1.8.0") {
[15:32:49.055]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:49.055]                               "", base::R.version$version.string), 
[15:32:49.055]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:49.055]                                 base::R.version$platform, 8 * 
[15:32:49.055]                                   base::.Machine$sizeof.pointer), 
[15:32:49.055]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:49.055]                                 "release", "version")], collapse = " "), 
[15:32:49.055]                               hostname = base::Sys.info()[["nodename"]])
[15:32:49.055]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:49.055]                               info)
[15:32:49.055]                             info <- base::paste(info, collapse = "; ")
[15:32:49.055]                             if (!has_future) {
[15:32:49.055]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:49.055]                                 info)
[15:32:49.055]                             }
[15:32:49.055]                             else {
[15:32:49.055]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:49.055]                                 info, version)
[15:32:49.055]                             }
[15:32:49.055]                             base::stop(msg)
[15:32:49.055]                           }
[15:32:49.055]                         })
[15:32:49.055]                       }
[15:32:49.055]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:49.055]                       base::options(mc.cores = 1L)
[15:32:49.055]                     }
[15:32:49.055]                     base::local({
[15:32:49.055]                       for (pkg in "future.apply") {
[15:32:49.055]                         base::loadNamespace(pkg)
[15:32:49.055]                         base::library(pkg, character.only = TRUE)
[15:32:49.055]                       }
[15:32:49.055]                     })
[15:32:49.055]                   }
[15:32:49.055]                   ...future.strategy.old <- future::plan("list")
[15:32:49.055]                   options(future.plan = NULL)
[15:32:49.055]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.055]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:49.055]                 }
[15:32:49.055]                 ...future.workdir <- getwd()
[15:32:49.055]             }
[15:32:49.055]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:49.055]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:49.055]         }
[15:32:49.055]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:49.055]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:49.055]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:49.055]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:49.055]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:49.055]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:49.055]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:49.055]             base::names(...future.oldOptions))
[15:32:49.055]     }
[15:32:49.055]     if (FALSE) {
[15:32:49.055]     }
[15:32:49.055]     else {
[15:32:49.055]         if (TRUE) {
[15:32:49.055]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:49.055]                 open = "w")
[15:32:49.055]         }
[15:32:49.055]         else {
[15:32:49.055]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:49.055]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:49.055]         }
[15:32:49.055]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:49.055]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:49.055]             base::sink(type = "output", split = FALSE)
[15:32:49.055]             base::close(...future.stdout)
[15:32:49.055]         }, add = TRUE)
[15:32:49.055]     }
[15:32:49.055]     ...future.frame <- base::sys.nframe()
[15:32:49.055]     ...future.conditions <- base::list()
[15:32:49.055]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:49.055]     if (FALSE) {
[15:32:49.055]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:49.055]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:49.055]     }
[15:32:49.055]     ...future.result <- base::tryCatch({
[15:32:49.055]         base::withCallingHandlers({
[15:32:49.055]             ...future.value <- base::withVisible(base::local({
[15:32:49.055]                 ...future.makeSendCondition <- base::local({
[15:32:49.055]                   sendCondition <- NULL
[15:32:49.055]                   function(frame = 1L) {
[15:32:49.055]                     if (is.function(sendCondition)) 
[15:32:49.055]                       return(sendCondition)
[15:32:49.055]                     ns <- getNamespace("parallel")
[15:32:49.055]                     if (exists("sendData", mode = "function", 
[15:32:49.055]                       envir = ns)) {
[15:32:49.055]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:49.055]                         envir = ns)
[15:32:49.055]                       envir <- sys.frame(frame)
[15:32:49.055]                       master <- NULL
[15:32:49.055]                       while (!identical(envir, .GlobalEnv) && 
[15:32:49.055]                         !identical(envir, emptyenv())) {
[15:32:49.055]                         if (exists("master", mode = "list", envir = envir, 
[15:32:49.055]                           inherits = FALSE)) {
[15:32:49.055]                           master <- get("master", mode = "list", 
[15:32:49.055]                             envir = envir, inherits = FALSE)
[15:32:49.055]                           if (inherits(master, c("SOCKnode", 
[15:32:49.055]                             "SOCK0node"))) {
[15:32:49.055]                             sendCondition <<- function(cond) {
[15:32:49.055]                               data <- list(type = "VALUE", value = cond, 
[15:32:49.055]                                 success = TRUE)
[15:32:49.055]                               parallel_sendData(master, data)
[15:32:49.055]                             }
[15:32:49.055]                             return(sendCondition)
[15:32:49.055]                           }
[15:32:49.055]                         }
[15:32:49.055]                         frame <- frame + 1L
[15:32:49.055]                         envir <- sys.frame(frame)
[15:32:49.055]                       }
[15:32:49.055]                     }
[15:32:49.055]                     sendCondition <<- function(cond) NULL
[15:32:49.055]                   }
[15:32:49.055]                 })
[15:32:49.055]                 withCallingHandlers({
[15:32:49.055]                   {
[15:32:49.055]                     do.call(function(...) {
[15:32:49.055]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.055]                       if (!identical(...future.globals.maxSize.org, 
[15:32:49.055]                         ...future.globals.maxSize)) {
[15:32:49.055]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.055]                         on.exit(options(oopts), add = TRUE)
[15:32:49.055]                       }
[15:32:49.055]                       {
[15:32:49.055]                         lapply(seq_along(...future.elements_ii), 
[15:32:49.055]                           FUN = function(jj) {
[15:32:49.055]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.055]                             ...future.FUN(...future.X_jj, ...)
[15:32:49.055]                           })
[15:32:49.055]                       }
[15:32:49.055]                     }, args = future.call.arguments)
[15:32:49.055]                   }
[15:32:49.055]                 }, immediateCondition = function(cond) {
[15:32:49.055]                   sendCondition <- ...future.makeSendCondition()
[15:32:49.055]                   sendCondition(cond)
[15:32:49.055]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.055]                   {
[15:32:49.055]                     inherits <- base::inherits
[15:32:49.055]                     invokeRestart <- base::invokeRestart
[15:32:49.055]                     is.null <- base::is.null
[15:32:49.055]                     muffled <- FALSE
[15:32:49.055]                     if (inherits(cond, "message")) {
[15:32:49.055]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:49.055]                       if (muffled) 
[15:32:49.055]                         invokeRestart("muffleMessage")
[15:32:49.055]                     }
[15:32:49.055]                     else if (inherits(cond, "warning")) {
[15:32:49.055]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:49.055]                       if (muffled) 
[15:32:49.055]                         invokeRestart("muffleWarning")
[15:32:49.055]                     }
[15:32:49.055]                     else if (inherits(cond, "condition")) {
[15:32:49.055]                       if (!is.null(pattern)) {
[15:32:49.055]                         computeRestarts <- base::computeRestarts
[15:32:49.055]                         grepl <- base::grepl
[15:32:49.055]                         restarts <- computeRestarts(cond)
[15:32:49.055]                         for (restart in restarts) {
[15:32:49.055]                           name <- restart$name
[15:32:49.055]                           if (is.null(name)) 
[15:32:49.055]                             next
[15:32:49.055]                           if (!grepl(pattern, name)) 
[15:32:49.055]                             next
[15:32:49.055]                           invokeRestart(restart)
[15:32:49.055]                           muffled <- TRUE
[15:32:49.055]                           break
[15:32:49.055]                         }
[15:32:49.055]                       }
[15:32:49.055]                     }
[15:32:49.055]                     invisible(muffled)
[15:32:49.055]                   }
[15:32:49.055]                   muffleCondition(cond)
[15:32:49.055]                 })
[15:32:49.055]             }))
[15:32:49.055]             future::FutureResult(value = ...future.value$value, 
[15:32:49.055]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.055]                   ...future.rng), globalenv = if (FALSE) 
[15:32:49.055]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:49.055]                     ...future.globalenv.names))
[15:32:49.055]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:49.055]         }, condition = base::local({
[15:32:49.055]             c <- base::c
[15:32:49.055]             inherits <- base::inherits
[15:32:49.055]             invokeRestart <- base::invokeRestart
[15:32:49.055]             length <- base::length
[15:32:49.055]             list <- base::list
[15:32:49.055]             seq.int <- base::seq.int
[15:32:49.055]             signalCondition <- base::signalCondition
[15:32:49.055]             sys.calls <- base::sys.calls
[15:32:49.055]             `[[` <- base::`[[`
[15:32:49.055]             `+` <- base::`+`
[15:32:49.055]             `<<-` <- base::`<<-`
[15:32:49.055]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:49.055]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:49.055]                   3L)]
[15:32:49.055]             }
[15:32:49.055]             function(cond) {
[15:32:49.055]                 is_error <- inherits(cond, "error")
[15:32:49.055]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:49.055]                   NULL)
[15:32:49.055]                 if (is_error) {
[15:32:49.055]                   sessionInformation <- function() {
[15:32:49.055]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:49.055]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:49.055]                       search = base::search(), system = base::Sys.info())
[15:32:49.055]                   }
[15:32:49.055]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.055]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:49.055]                     cond$call), session = sessionInformation(), 
[15:32:49.055]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:49.055]                   signalCondition(cond)
[15:32:49.055]                 }
[15:32:49.055]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:49.055]                 "immediateCondition"))) {
[15:32:49.055]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:49.055]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.055]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:49.055]                   if (TRUE && !signal) {
[15:32:49.055]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.055]                     {
[15:32:49.055]                       inherits <- base::inherits
[15:32:49.055]                       invokeRestart <- base::invokeRestart
[15:32:49.055]                       is.null <- base::is.null
[15:32:49.055]                       muffled <- FALSE
[15:32:49.055]                       if (inherits(cond, "message")) {
[15:32:49.055]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.055]                         if (muffled) 
[15:32:49.055]                           invokeRestart("muffleMessage")
[15:32:49.055]                       }
[15:32:49.055]                       else if (inherits(cond, "warning")) {
[15:32:49.055]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.055]                         if (muffled) 
[15:32:49.055]                           invokeRestart("muffleWarning")
[15:32:49.055]                       }
[15:32:49.055]                       else if (inherits(cond, "condition")) {
[15:32:49.055]                         if (!is.null(pattern)) {
[15:32:49.055]                           computeRestarts <- base::computeRestarts
[15:32:49.055]                           grepl <- base::grepl
[15:32:49.055]                           restarts <- computeRestarts(cond)
[15:32:49.055]                           for (restart in restarts) {
[15:32:49.055]                             name <- restart$name
[15:32:49.055]                             if (is.null(name)) 
[15:32:49.055]                               next
[15:32:49.055]                             if (!grepl(pattern, name)) 
[15:32:49.055]                               next
[15:32:49.055]                             invokeRestart(restart)
[15:32:49.055]                             muffled <- TRUE
[15:32:49.055]                             break
[15:32:49.055]                           }
[15:32:49.055]                         }
[15:32:49.055]                       }
[15:32:49.055]                       invisible(muffled)
[15:32:49.055]                     }
[15:32:49.055]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.055]                   }
[15:32:49.055]                 }
[15:32:49.055]                 else {
[15:32:49.055]                   if (TRUE) {
[15:32:49.055]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.055]                     {
[15:32:49.055]                       inherits <- base::inherits
[15:32:49.055]                       invokeRestart <- base::invokeRestart
[15:32:49.055]                       is.null <- base::is.null
[15:32:49.055]                       muffled <- FALSE
[15:32:49.055]                       if (inherits(cond, "message")) {
[15:32:49.055]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.055]                         if (muffled) 
[15:32:49.055]                           invokeRestart("muffleMessage")
[15:32:49.055]                       }
[15:32:49.055]                       else if (inherits(cond, "warning")) {
[15:32:49.055]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.055]                         if (muffled) 
[15:32:49.055]                           invokeRestart("muffleWarning")
[15:32:49.055]                       }
[15:32:49.055]                       else if (inherits(cond, "condition")) {
[15:32:49.055]                         if (!is.null(pattern)) {
[15:32:49.055]                           computeRestarts <- base::computeRestarts
[15:32:49.055]                           grepl <- base::grepl
[15:32:49.055]                           restarts <- computeRestarts(cond)
[15:32:49.055]                           for (restart in restarts) {
[15:32:49.055]                             name <- restart$name
[15:32:49.055]                             if (is.null(name)) 
[15:32:49.055]                               next
[15:32:49.055]                             if (!grepl(pattern, name)) 
[15:32:49.055]                               next
[15:32:49.055]                             invokeRestart(restart)
[15:32:49.055]                             muffled <- TRUE
[15:32:49.055]                             break
[15:32:49.055]                           }
[15:32:49.055]                         }
[15:32:49.055]                       }
[15:32:49.055]                       invisible(muffled)
[15:32:49.055]                     }
[15:32:49.055]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.055]                   }
[15:32:49.055]                 }
[15:32:49.055]             }
[15:32:49.055]         }))
[15:32:49.055]     }, error = function(ex) {
[15:32:49.055]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:49.055]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.055]                 ...future.rng), started = ...future.startTime, 
[15:32:49.055]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:49.055]             version = "1.8"), class = "FutureResult")
[15:32:49.055]     }, finally = {
[15:32:49.055]         if (!identical(...future.workdir, getwd())) 
[15:32:49.055]             setwd(...future.workdir)
[15:32:49.055]         {
[15:32:49.055]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:49.055]                 ...future.oldOptions$nwarnings <- NULL
[15:32:49.055]             }
[15:32:49.055]             base::options(...future.oldOptions)
[15:32:49.055]             if (.Platform$OS.type == "windows") {
[15:32:49.055]                 old_names <- names(...future.oldEnvVars)
[15:32:49.055]                 envs <- base::Sys.getenv()
[15:32:49.055]                 names <- names(envs)
[15:32:49.055]                 common <- intersect(names, old_names)
[15:32:49.055]                 added <- setdiff(names, old_names)
[15:32:49.055]                 removed <- setdiff(old_names, names)
[15:32:49.055]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:49.055]                   envs[common]]
[15:32:49.055]                 NAMES <- toupper(changed)
[15:32:49.055]                 args <- list()
[15:32:49.055]                 for (kk in seq_along(NAMES)) {
[15:32:49.055]                   name <- changed[[kk]]
[15:32:49.055]                   NAME <- NAMES[[kk]]
[15:32:49.055]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.055]                     next
[15:32:49.055]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.055]                 }
[15:32:49.055]                 NAMES <- toupper(added)
[15:32:49.055]                 for (kk in seq_along(NAMES)) {
[15:32:49.055]                   name <- added[[kk]]
[15:32:49.055]                   NAME <- NAMES[[kk]]
[15:32:49.055]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.055]                     next
[15:32:49.055]                   args[[name]] <- ""
[15:32:49.055]                 }
[15:32:49.055]                 NAMES <- toupper(removed)
[15:32:49.055]                 for (kk in seq_along(NAMES)) {
[15:32:49.055]                   name <- removed[[kk]]
[15:32:49.055]                   NAME <- NAMES[[kk]]
[15:32:49.055]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.055]                     next
[15:32:49.055]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.055]                 }
[15:32:49.055]                 if (length(args) > 0) 
[15:32:49.055]                   base::do.call(base::Sys.setenv, args = args)
[15:32:49.055]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:49.055]             }
[15:32:49.055]             else {
[15:32:49.055]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:49.055]             }
[15:32:49.055]             {
[15:32:49.055]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:49.055]                   0L) {
[15:32:49.055]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:49.055]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:49.055]                   base::options(opts)
[15:32:49.055]                 }
[15:32:49.055]                 {
[15:32:49.055]                   {
[15:32:49.055]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:49.055]                     NULL
[15:32:49.055]                   }
[15:32:49.055]                   options(future.plan = NULL)
[15:32:49.055]                   if (is.na(NA_character_)) 
[15:32:49.055]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.055]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:49.055]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:49.055]                     .init = FALSE)
[15:32:49.055]                 }
[15:32:49.055]             }
[15:32:49.055]         }
[15:32:49.055]     })
[15:32:49.055]     if (TRUE) {
[15:32:49.055]         base::sink(type = "output", split = FALSE)
[15:32:49.055]         if (TRUE) {
[15:32:49.055]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:49.055]         }
[15:32:49.055]         else {
[15:32:49.055]             ...future.result["stdout"] <- base::list(NULL)
[15:32:49.055]         }
[15:32:49.055]         base::close(...future.stdout)
[15:32:49.055]         ...future.stdout <- NULL
[15:32:49.055]     }
[15:32:49.055]     ...future.result$conditions <- ...future.conditions
[15:32:49.055]     ...future.result$finished <- base::Sys.time()
[15:32:49.055]     ...future.result
[15:32:49.055] }
[15:32:49.064] Exporting 11 global objects (103.08 KiB) to cluster node #1 ...
[15:32:49.064] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:49.065] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:49.065] Exporting 'x_FUN' (10.95 KiB) to cluster node #1 ...
[15:32:49.066] Exporting 'x_FUN' (10.95 KiB) to cluster node #1 ... DONE
[15:32:49.066] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:49.067] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:49.067] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:49.068] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:49.068] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:49.069] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:49.069] Exporting 'dim' (56 bytes) to cluster node #1 ...
[15:32:49.070] Exporting 'dim' (56 bytes) to cluster node #1 ... DONE
[15:32:49.070] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:49.071] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:49.072] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:49.072] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:49.073] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ...
[15:32:49.073] Exporting '...future.elements_ii' (280 bytes) to cluster node #1 ... DONE
[15:32:49.074] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:49.074] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:49.074] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:49.075] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:49.075] Exporting 11 global objects (103.08 KiB) to cluster node #1 ... DONE
[15:32:49.076] MultisessionFuture started
[15:32:49.077] - Launch lazy future ... done
[15:32:49.077] run() for 'MultisessionFuture' ... done
[15:32:49.077] Created future:
[15:32:49.103] receiveMessageFromWorker() for ClusterFuture ...
[15:32:49.103] - Validating connection of MultisessionFuture
[15:32:49.104] - received message: FutureResult
[15:32:49.104] - Received FutureResult
[15:32:49.104] - Erased future from FutureRegistry
[15:32:49.105] result() for ClusterFuture ...
[15:32:49.105] - result already collected: FutureResult
[15:32:49.105] result() for ClusterFuture ... done
[15:32:49.105] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:49.077] MultisessionFuture:
[15:32:49.077] Label: 'future_vapply-2'
[15:32:49.077] Expression:
[15:32:49.077] {
[15:32:49.077]     do.call(function(...) {
[15:32:49.077]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.077]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.077]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.077]             on.exit(options(oopts), add = TRUE)
[15:32:49.077]         }
[15:32:49.077]         {
[15:32:49.077]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.077]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.077]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.077]             })
[15:32:49.077]         }
[15:32:49.077]     }, args = future.call.arguments)
[15:32:49.077] }
[15:32:49.077] Lazy evaluation: FALSE
[15:32:49.077] Asynchronous evaluation: TRUE
[15:32:49.077] Local evaluation: TRUE
[15:32:49.077] Environment: R_GlobalEnv
[15:32:49.077] Capture standard output: TRUE
[15:32:49.077] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:49.077] Globals: 11 objects totaling 103.35 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 10.95 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:49.077] Packages: 1 packages ('future.apply')
[15:32:49.077] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:49.077] Resolved: TRUE
[15:32:49.077] Value: <not collected>
[15:32:49.077] Conditions captured: <none>
[15:32:49.077] Early signaling: FALSE
[15:32:49.077] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:49.077] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.106] Chunk #2 of 2 ... DONE
[15:32:49.106] Launching 2 futures (chunks) ... DONE
[15:32:49.107] Resolving 2 futures (chunks) ...
[15:32:49.107] resolve() on list ...
[15:32:49.107]  recursive: 0
[15:32:49.108]  length: 2
[15:32:49.108] 
[15:32:49.108] Future #1
[15:32:49.108] result() for ClusterFuture ...
[15:32:49.109] - result already collected: FutureResult
[15:32:49.109] result() for ClusterFuture ... done
[15:32:49.109] result() for ClusterFuture ...
[15:32:49.109] - result already collected: FutureResult
[15:32:49.110] result() for ClusterFuture ... done
[15:32:49.110] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:49.110] - nx: 2
[15:32:49.110] - relay: TRUE
[15:32:49.111] - stdout: TRUE
[15:32:49.111] - signal: TRUE
[15:32:49.111] - resignal: FALSE
[15:32:49.111] - force: TRUE
[15:32:49.112] - relayed: [n=2] FALSE, FALSE
[15:32:49.112] - queued futures: [n=2] FALSE, FALSE
[15:32:49.112]  - until=1
[15:32:49.112]  - relaying element #1
[15:32:49.113] result() for ClusterFuture ...
[15:32:49.113] - result already collected: FutureResult
[15:32:49.113] result() for ClusterFuture ... done
[15:32:49.113] result() for ClusterFuture ...
[15:32:49.114] - result already collected: FutureResult
[15:32:49.114] result() for ClusterFuture ... done
[15:32:49.114] result() for ClusterFuture ...
[15:32:49.114] - result already collected: FutureResult
[15:32:49.115] result() for ClusterFuture ... done
[15:32:49.115] result() for ClusterFuture ...
[15:32:49.115] - result already collected: FutureResult
[15:32:49.115] result() for ClusterFuture ... done
[15:32:49.115] - relayed: [n=2] TRUE, FALSE
[15:32:49.116] - queued futures: [n=2] TRUE, FALSE
[15:32:49.116] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:49.116]  length: 1 (resolved future 1)
[15:32:49.117] Future #2
[15:32:49.117] result() for ClusterFuture ...
[15:32:49.117] - result already collected: FutureResult
[15:32:49.117] result() for ClusterFuture ... done
[15:32:49.117] result() for ClusterFuture ...
[15:32:49.118] - result already collected: FutureResult
[15:32:49.118] result() for ClusterFuture ... done
[15:32:49.118] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:49.118] - nx: 2
[15:32:49.119] - relay: TRUE
[15:32:49.119] - stdout: TRUE
[15:32:49.119] - signal: TRUE
[15:32:49.119] - resignal: FALSE
[15:32:49.120] - force: TRUE
[15:32:49.120] - relayed: [n=2] TRUE, FALSE
[15:32:49.120] - queued futures: [n=2] TRUE, FALSE
[15:32:49.120]  - until=2
[15:32:49.121]  - relaying element #2
[15:32:49.121] result() for ClusterFuture ...
[15:32:49.121] - result already collected: FutureResult
[15:32:49.121] result() for ClusterFuture ... done
[15:32:49.121] result() for ClusterFuture ...
[15:32:49.122] - result already collected: FutureResult
[15:32:49.122] result() for ClusterFuture ... done
[15:32:49.122] result() for ClusterFuture ...
[15:32:49.122] - result already collected: FutureResult
[15:32:49.123] result() for ClusterFuture ... done
[15:32:49.123] result() for ClusterFuture ...
[15:32:49.123] - result already collected: FutureResult
[15:32:49.123] result() for ClusterFuture ... done
[15:32:49.124] - relayed: [n=2] TRUE, TRUE
[15:32:49.124] - queued futures: [n=2] TRUE, TRUE
[15:32:49.124] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:49.124]  length: 0 (resolved future 2)
[15:32:49.125] Relaying remaining futures
[15:32:49.125] signalConditionsASAP(NULL, pos=0) ...
[15:32:49.125] - nx: 2
[15:32:49.125] - relay: TRUE
[15:32:49.126] - stdout: TRUE
[15:32:49.126] - signal: TRUE
[15:32:49.126] - resignal: FALSE
[15:32:49.126] - force: TRUE
[15:32:49.126] - relayed: [n=2] TRUE, TRUE
[15:32:49.127] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:49.127] - relayed: [n=2] TRUE, TRUE
[15:32:49.127] - queued futures: [n=2] TRUE, TRUE
[15:32:49.128] signalConditionsASAP(NULL, pos=0) ... done
[15:32:49.128] resolve() on list ... DONE
[15:32:49.128] result() for ClusterFuture ...
[15:32:49.128] - result already collected: FutureResult
[15:32:49.128] result() for ClusterFuture ... done
[15:32:49.129] result() for ClusterFuture ...
[15:32:49.129] - result already collected: FutureResult
[15:32:49.129] result() for ClusterFuture ... done
[15:32:49.130] result() for ClusterFuture ...
[15:32:49.130] - result already collected: FutureResult
[15:32:49.130] result() for ClusterFuture ... done
[15:32:49.130] result() for ClusterFuture ...
[15:32:49.130] - result already collected: FutureResult
[15:32:49.131] result() for ClusterFuture ... done
[15:32:49.131]  - Number of value chunks collected: 2
[15:32:49.131] Resolving 2 futures (chunks) ... DONE
[15:32:49.131] Reducing values from 2 chunks ...
[15:32:49.132]  - Number of values collected after concatenation: 10
[15:32:49.132]  - Number of values expected: 10
[15:32:49.132] Reducing values from 2 chunks ... DONE
[15:32:49.132] future_lapply() ... DONE
 int [1:2, 1:2, 1:10] 1 1 1 1 2 2 2 2 3 3 ...
 - attr(*, "dimnames")=List of 3
  ..$ : chr [1:2] "a" "b"
  ..$ : chr [1:2] "A" "B"
  ..$ : NULL
- From example(vapply) ...
[15:32:49.137] future_lapply() ...
[15:32:49.144] Number of chunks: 2
[15:32:49.144] getGlobalsAndPackagesXApply() ...
[15:32:49.144]  - future.globals: TRUE
[15:32:49.144] getGlobalsAndPackages() ...
[15:32:49.145] Searching for globals...
[15:32:49.151] - globals found: [17] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'UseMethod'
[15:32:49.151] Searching for globals ... DONE
[15:32:49.152] Resolving globals: FALSE
[15:32:49.153] The total size of the 7 globals is 93.29 KiB (95528 bytes)
[15:32:49.154] The total size of the 7 globals exported for future expression ('FUN()') is 93.29 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:49.154] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:49.155] - packages: [2] 'stats', 'future.apply'
[15:32:49.155] getGlobalsAndPackages() ... DONE
[15:32:49.155]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:49.155]  - needed namespaces: [n=2] 'stats', 'future.apply'
[15:32:49.156] Finding globals ... DONE
[15:32:49.156]  - use_args: TRUE
[15:32:49.156]  - Getting '...' globals ...
[15:32:49.157] resolve() on list ...
[15:32:49.157]  recursive: 0
[15:32:49.157]  length: 1
[15:32:49.158]  elements: '...'
[15:32:49.158]  length: 0 (resolved future 1)
[15:32:49.158] resolve() on list ... DONE
[15:32:49.158]    - '...' content: [n=0] 
[15:32:49.159] List of 1
[15:32:49.159]  $ ...: list()
[15:32:49.159]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:49.159]  - attr(*, "where")=List of 1
[15:32:49.159]   ..$ ...:<environment: 0x0000022d40794570> 
[15:32:49.159]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:49.159]  - attr(*, "resolved")= logi TRUE
[15:32:49.159]  - attr(*, "total_size")= num NA
[15:32:49.163]  - Getting '...' globals ... DONE
[15:32:49.163] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:49.164] List of 8
[15:32:49.164]  $ ...future.FUN:function (x, ...)  
[15:32:49.164]  $ x_FUN        :function (x, ...)  
[15:32:49.164]  $ times        : int 5
[15:32:49.164]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:49.164]  $ stop_if_not  :function (...)  
[15:32:49.164]  $ dim          : NULL
[15:32:49.164]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:49.164]  $ ...          : list()
[15:32:49.164]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:49.164]  - attr(*, "where")=List of 8
[15:32:49.164]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:49.164]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:49.164]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:49.164]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:49.164]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:49.164]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:49.164]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:49.164]   ..$ ...          :<environment: 0x0000022d40794570> 
[15:32:49.164]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:49.164]  - attr(*, "resolved")= logi FALSE
[15:32:49.164]  - attr(*, "total_size")= num 95528
[15:32:49.173] Packages to be attached in all futures: [n=2] 'stats', 'future.apply'
[15:32:49.173] getGlobalsAndPackagesXApply() ... DONE
[15:32:49.174] Number of futures (= number of chunks): 2
[15:32:49.174] Launching 2 futures (chunks) ...
[15:32:49.174] Chunk #1 of 2 ...
[15:32:49.175]  - Finding globals in 'X' for chunk #1 ...
[15:32:49.175] getGlobalsAndPackages() ...
[15:32:49.175] Searching for globals...
[15:32:49.176] 
[15:32:49.176] Searching for globals ... DONE
[15:32:49.176] - globals: [0] <none>
[15:32:49.176] getGlobalsAndPackages() ... DONE
[15:32:49.177]    + additional globals found: [n=0] 
[15:32:49.177]    + additional namespaces needed: [n=0] 
[15:32:49.177]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:49.177]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:49.178]  - seeds: <none>
[15:32:49.178]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.178] getGlobalsAndPackages() ...
[15:32:49.178] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.179] Resolving globals: FALSE
[15:32:49.179] Tweak future expression to call with '...' arguments ...
[15:32:49.179] {
[15:32:49.179]     do.call(function(...) {
[15:32:49.179]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.179]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.179]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.179]             on.exit(options(oopts), add = TRUE)
[15:32:49.179]         }
[15:32:49.179]         {
[15:32:49.179]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.179]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.179]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.179]             })
[15:32:49.179]         }
[15:32:49.179]     }, args = future.call.arguments)
[15:32:49.179] }
[15:32:49.180] Tweak future expression to call with '...' arguments ... DONE
[15:32:49.181] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.181] - packages: [2] 'stats', 'future.apply'
[15:32:49.182] getGlobalsAndPackages() ... DONE
[15:32:49.182] run() for 'Future' ...
[15:32:49.182] - state: 'created'
[15:32:49.183] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:49.199] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.200] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:49.200]   - Field: 'node'
[15:32:49.200]   - Field: 'label'
[15:32:49.201]   - Field: 'local'
[15:32:49.201]   - Field: 'owner'
[15:32:49.201]   - Field: 'envir'
[15:32:49.201]   - Field: 'workers'
[15:32:49.202]   - Field: 'packages'
[15:32:49.202]   - Field: 'gc'
[15:32:49.202]   - Field: 'conditions'
[15:32:49.203]   - Field: 'persistent'
[15:32:49.203]   - Field: 'expr'
[15:32:49.203]   - Field: 'uuid'
[15:32:49.203]   - Field: 'seed'
[15:32:49.204]   - Field: 'version'
[15:32:49.204]   - Field: 'result'
[15:32:49.204]   - Field: 'asynchronous'
[15:32:49.205]   - Field: 'calls'
[15:32:49.205]   - Field: 'globals'
[15:32:49.205]   - Field: 'stdout'
[15:32:49.205]   - Field: 'earlySignal'
[15:32:49.206]   - Field: 'lazy'
[15:32:49.206]   - Field: 'state'
[15:32:49.206] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:49.206] - Launch lazy future ...
[15:32:49.207] Packages needed by the future expression (n = 2): 'stats', 'future.apply'
[15:32:49.207] Packages needed by future strategies (n = 0): <none>
[15:32:49.208] {
[15:32:49.208]     {
[15:32:49.208]         {
[15:32:49.208]             ...future.startTime <- base::Sys.time()
[15:32:49.208]             {
[15:32:49.208]                 {
[15:32:49.208]                   {
[15:32:49.208]                     {
[15:32:49.208]                       {
[15:32:49.208]                         base::local({
[15:32:49.208]                           has_future <- base::requireNamespace("future", 
[15:32:49.208]                             quietly = TRUE)
[15:32:49.208]                           if (has_future) {
[15:32:49.208]                             ns <- base::getNamespace("future")
[15:32:49.208]                             version <- ns[[".package"]][["version"]]
[15:32:49.208]                             if (is.null(version)) 
[15:32:49.208]                               version <- utils::packageVersion("future")
[15:32:49.208]                           }
[15:32:49.208]                           else {
[15:32:49.208]                             version <- NULL
[15:32:49.208]                           }
[15:32:49.208]                           if (!has_future || version < "1.8.0") {
[15:32:49.208]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:49.208]                               "", base::R.version$version.string), 
[15:32:49.208]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:49.208]                                 base::R.version$platform, 8 * 
[15:32:49.208]                                   base::.Machine$sizeof.pointer), 
[15:32:49.208]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:49.208]                                 "release", "version")], collapse = " "), 
[15:32:49.208]                               hostname = base::Sys.info()[["nodename"]])
[15:32:49.208]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:49.208]                               info)
[15:32:49.208]                             info <- base::paste(info, collapse = "; ")
[15:32:49.208]                             if (!has_future) {
[15:32:49.208]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:49.208]                                 info)
[15:32:49.208]                             }
[15:32:49.208]                             else {
[15:32:49.208]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:49.208]                                 info, version)
[15:32:49.208]                             }
[15:32:49.208]                             base::stop(msg)
[15:32:49.208]                           }
[15:32:49.208]                         })
[15:32:49.208]                       }
[15:32:49.208]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:49.208]                       base::options(mc.cores = 1L)
[15:32:49.208]                     }
[15:32:49.208]                     base::local({
[15:32:49.208]                       for (pkg in c("stats", "future.apply")) {
[15:32:49.208]                         base::loadNamespace(pkg)
[15:32:49.208]                         base::library(pkg, character.only = TRUE)
[15:32:49.208]                       }
[15:32:49.208]                     })
[15:32:49.208]                   }
[15:32:49.208]                   ...future.strategy.old <- future::plan("list")
[15:32:49.208]                   options(future.plan = NULL)
[15:32:49.208]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.208]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:49.208]                 }
[15:32:49.208]                 ...future.workdir <- getwd()
[15:32:49.208]             }
[15:32:49.208]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:49.208]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:49.208]         }
[15:32:49.208]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:49.208]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:49.208]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:49.208]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:49.208]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:49.208]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:49.208]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:49.208]             base::names(...future.oldOptions))
[15:32:49.208]     }
[15:32:49.208]     if (FALSE) {
[15:32:49.208]     }
[15:32:49.208]     else {
[15:32:49.208]         if (TRUE) {
[15:32:49.208]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:49.208]                 open = "w")
[15:32:49.208]         }
[15:32:49.208]         else {
[15:32:49.208]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:49.208]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:49.208]         }
[15:32:49.208]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:49.208]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:49.208]             base::sink(type = "output", split = FALSE)
[15:32:49.208]             base::close(...future.stdout)
[15:32:49.208]         }, add = TRUE)
[15:32:49.208]     }
[15:32:49.208]     ...future.frame <- base::sys.nframe()
[15:32:49.208]     ...future.conditions <- base::list()
[15:32:49.208]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:49.208]     if (FALSE) {
[15:32:49.208]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:49.208]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:49.208]     }
[15:32:49.208]     ...future.result <- base::tryCatch({
[15:32:49.208]         base::withCallingHandlers({
[15:32:49.208]             ...future.value <- base::withVisible(base::local({
[15:32:49.208]                 ...future.makeSendCondition <- base::local({
[15:32:49.208]                   sendCondition <- NULL
[15:32:49.208]                   function(frame = 1L) {
[15:32:49.208]                     if (is.function(sendCondition)) 
[15:32:49.208]                       return(sendCondition)
[15:32:49.208]                     ns <- getNamespace("parallel")
[15:32:49.208]                     if (exists("sendData", mode = "function", 
[15:32:49.208]                       envir = ns)) {
[15:32:49.208]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:49.208]                         envir = ns)
[15:32:49.208]                       envir <- sys.frame(frame)
[15:32:49.208]                       master <- NULL
[15:32:49.208]                       while (!identical(envir, .GlobalEnv) && 
[15:32:49.208]                         !identical(envir, emptyenv())) {
[15:32:49.208]                         if (exists("master", mode = "list", envir = envir, 
[15:32:49.208]                           inherits = FALSE)) {
[15:32:49.208]                           master <- get("master", mode = "list", 
[15:32:49.208]                             envir = envir, inherits = FALSE)
[15:32:49.208]                           if (inherits(master, c("SOCKnode", 
[15:32:49.208]                             "SOCK0node"))) {
[15:32:49.208]                             sendCondition <<- function(cond) {
[15:32:49.208]                               data <- list(type = "VALUE", value = cond, 
[15:32:49.208]                                 success = TRUE)
[15:32:49.208]                               parallel_sendData(master, data)
[15:32:49.208]                             }
[15:32:49.208]                             return(sendCondition)
[15:32:49.208]                           }
[15:32:49.208]                         }
[15:32:49.208]                         frame <- frame + 1L
[15:32:49.208]                         envir <- sys.frame(frame)
[15:32:49.208]                       }
[15:32:49.208]                     }
[15:32:49.208]                     sendCondition <<- function(cond) NULL
[15:32:49.208]                   }
[15:32:49.208]                 })
[15:32:49.208]                 withCallingHandlers({
[15:32:49.208]                   {
[15:32:49.208]                     do.call(function(...) {
[15:32:49.208]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.208]                       if (!identical(...future.globals.maxSize.org, 
[15:32:49.208]                         ...future.globals.maxSize)) {
[15:32:49.208]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.208]                         on.exit(options(oopts), add = TRUE)
[15:32:49.208]                       }
[15:32:49.208]                       {
[15:32:49.208]                         lapply(seq_along(...future.elements_ii), 
[15:32:49.208]                           FUN = function(jj) {
[15:32:49.208]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.208]                             ...future.FUN(...future.X_jj, ...)
[15:32:49.208]                           })
[15:32:49.208]                       }
[15:32:49.208]                     }, args = future.call.arguments)
[15:32:49.208]                   }
[15:32:49.208]                 }, immediateCondition = function(cond) {
[15:32:49.208]                   sendCondition <- ...future.makeSendCondition()
[15:32:49.208]                   sendCondition(cond)
[15:32:49.208]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.208]                   {
[15:32:49.208]                     inherits <- base::inherits
[15:32:49.208]                     invokeRestart <- base::invokeRestart
[15:32:49.208]                     is.null <- base::is.null
[15:32:49.208]                     muffled <- FALSE
[15:32:49.208]                     if (inherits(cond, "message")) {
[15:32:49.208]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:49.208]                       if (muffled) 
[15:32:49.208]                         invokeRestart("muffleMessage")
[15:32:49.208]                     }
[15:32:49.208]                     else if (inherits(cond, "warning")) {
[15:32:49.208]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:49.208]                       if (muffled) 
[15:32:49.208]                         invokeRestart("muffleWarning")
[15:32:49.208]                     }
[15:32:49.208]                     else if (inherits(cond, "condition")) {
[15:32:49.208]                       if (!is.null(pattern)) {
[15:32:49.208]                         computeRestarts <- base::computeRestarts
[15:32:49.208]                         grepl <- base::grepl
[15:32:49.208]                         restarts <- computeRestarts(cond)
[15:32:49.208]                         for (restart in restarts) {
[15:32:49.208]                           name <- restart$name
[15:32:49.208]                           if (is.null(name)) 
[15:32:49.208]                             next
[15:32:49.208]                           if (!grepl(pattern, name)) 
[15:32:49.208]                             next
[15:32:49.208]                           invokeRestart(restart)
[15:32:49.208]                           muffled <- TRUE
[15:32:49.208]                           break
[15:32:49.208]                         }
[15:32:49.208]                       }
[15:32:49.208]                     }
[15:32:49.208]                     invisible(muffled)
[15:32:49.208]                   }
[15:32:49.208]                   muffleCondition(cond)
[15:32:49.208]                 })
[15:32:49.208]             }))
[15:32:49.208]             future::FutureResult(value = ...future.value$value, 
[15:32:49.208]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.208]                   ...future.rng), globalenv = if (FALSE) 
[15:32:49.208]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:49.208]                     ...future.globalenv.names))
[15:32:49.208]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:49.208]         }, condition = base::local({
[15:32:49.208]             c <- base::c
[15:32:49.208]             inherits <- base::inherits
[15:32:49.208]             invokeRestart <- base::invokeRestart
[15:32:49.208]             length <- base::length
[15:32:49.208]             list <- base::list
[15:32:49.208]             seq.int <- base::seq.int
[15:32:49.208]             signalCondition <- base::signalCondition
[15:32:49.208]             sys.calls <- base::sys.calls
[15:32:49.208]             `[[` <- base::`[[`
[15:32:49.208]             `+` <- base::`+`
[15:32:49.208]             `<<-` <- base::`<<-`
[15:32:49.208]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:49.208]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:49.208]                   3L)]
[15:32:49.208]             }
[15:32:49.208]             function(cond) {
[15:32:49.208]                 is_error <- inherits(cond, "error")
[15:32:49.208]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:49.208]                   NULL)
[15:32:49.208]                 if (is_error) {
[15:32:49.208]                   sessionInformation <- function() {
[15:32:49.208]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:49.208]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:49.208]                       search = base::search(), system = base::Sys.info())
[15:32:49.208]                   }
[15:32:49.208]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.208]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:49.208]                     cond$call), session = sessionInformation(), 
[15:32:49.208]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:49.208]                   signalCondition(cond)
[15:32:49.208]                 }
[15:32:49.208]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:49.208]                 "immediateCondition"))) {
[15:32:49.208]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:49.208]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.208]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:49.208]                   if (TRUE && !signal) {
[15:32:49.208]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.208]                     {
[15:32:49.208]                       inherits <- base::inherits
[15:32:49.208]                       invokeRestart <- base::invokeRestart
[15:32:49.208]                       is.null <- base::is.null
[15:32:49.208]                       muffled <- FALSE
[15:32:49.208]                       if (inherits(cond, "message")) {
[15:32:49.208]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.208]                         if (muffled) 
[15:32:49.208]                           invokeRestart("muffleMessage")
[15:32:49.208]                       }
[15:32:49.208]                       else if (inherits(cond, "warning")) {
[15:32:49.208]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.208]                         if (muffled) 
[15:32:49.208]                           invokeRestart("muffleWarning")
[15:32:49.208]                       }
[15:32:49.208]                       else if (inherits(cond, "condition")) {
[15:32:49.208]                         if (!is.null(pattern)) {
[15:32:49.208]                           computeRestarts <- base::computeRestarts
[15:32:49.208]                           grepl <- base::grepl
[15:32:49.208]                           restarts <- computeRestarts(cond)
[15:32:49.208]                           for (restart in restarts) {
[15:32:49.208]                             name <- restart$name
[15:32:49.208]                             if (is.null(name)) 
[15:32:49.208]                               next
[15:32:49.208]                             if (!grepl(pattern, name)) 
[15:32:49.208]                               next
[15:32:49.208]                             invokeRestart(restart)
[15:32:49.208]                             muffled <- TRUE
[15:32:49.208]                             break
[15:32:49.208]                           }
[15:32:49.208]                         }
[15:32:49.208]                       }
[15:32:49.208]                       invisible(muffled)
[15:32:49.208]                     }
[15:32:49.208]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.208]                   }
[15:32:49.208]                 }
[15:32:49.208]                 else {
[15:32:49.208]                   if (TRUE) {
[15:32:49.208]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.208]                     {
[15:32:49.208]                       inherits <- base::inherits
[15:32:49.208]                       invokeRestart <- base::invokeRestart
[15:32:49.208]                       is.null <- base::is.null
[15:32:49.208]                       muffled <- FALSE
[15:32:49.208]                       if (inherits(cond, "message")) {
[15:32:49.208]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.208]                         if (muffled) 
[15:32:49.208]                           invokeRestart("muffleMessage")
[15:32:49.208]                       }
[15:32:49.208]                       else if (inherits(cond, "warning")) {
[15:32:49.208]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.208]                         if (muffled) 
[15:32:49.208]                           invokeRestart("muffleWarning")
[15:32:49.208]                       }
[15:32:49.208]                       else if (inherits(cond, "condition")) {
[15:32:49.208]                         if (!is.null(pattern)) {
[15:32:49.208]                           computeRestarts <- base::computeRestarts
[15:32:49.208]                           grepl <- base::grepl
[15:32:49.208]                           restarts <- computeRestarts(cond)
[15:32:49.208]                           for (restart in restarts) {
[15:32:49.208]                             name <- restart$name
[15:32:49.208]                             if (is.null(name)) 
[15:32:49.208]                               next
[15:32:49.208]                             if (!grepl(pattern, name)) 
[15:32:49.208]                               next
[15:32:49.208]                             invokeRestart(restart)
[15:32:49.208]                             muffled <- TRUE
[15:32:49.208]                             break
[15:32:49.208]                           }
[15:32:49.208]                         }
[15:32:49.208]                       }
[15:32:49.208]                       invisible(muffled)
[15:32:49.208]                     }
[15:32:49.208]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.208]                   }
[15:32:49.208]                 }
[15:32:49.208]             }
[15:32:49.208]         }))
[15:32:49.208]     }, error = function(ex) {
[15:32:49.208]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:49.208]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.208]                 ...future.rng), started = ...future.startTime, 
[15:32:49.208]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:49.208]             version = "1.8"), class = "FutureResult")
[15:32:49.208]     }, finally = {
[15:32:49.208]         if (!identical(...future.workdir, getwd())) 
[15:32:49.208]             setwd(...future.workdir)
[15:32:49.208]         {
[15:32:49.208]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:49.208]                 ...future.oldOptions$nwarnings <- NULL
[15:32:49.208]             }
[15:32:49.208]             base::options(...future.oldOptions)
[15:32:49.208]             if (.Platform$OS.type == "windows") {
[15:32:49.208]                 old_names <- names(...future.oldEnvVars)
[15:32:49.208]                 envs <- base::Sys.getenv()
[15:32:49.208]                 names <- names(envs)
[15:32:49.208]                 common <- intersect(names, old_names)
[15:32:49.208]                 added <- setdiff(names, old_names)
[15:32:49.208]                 removed <- setdiff(old_names, names)
[15:32:49.208]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:49.208]                   envs[common]]
[15:32:49.208]                 NAMES <- toupper(changed)
[15:32:49.208]                 args <- list()
[15:32:49.208]                 for (kk in seq_along(NAMES)) {
[15:32:49.208]                   name <- changed[[kk]]
[15:32:49.208]                   NAME <- NAMES[[kk]]
[15:32:49.208]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.208]                     next
[15:32:49.208]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.208]                 }
[15:32:49.208]                 NAMES <- toupper(added)
[15:32:49.208]                 for (kk in seq_along(NAMES)) {
[15:32:49.208]                   name <- added[[kk]]
[15:32:49.208]                   NAME <- NAMES[[kk]]
[15:32:49.208]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.208]                     next
[15:32:49.208]                   args[[name]] <- ""
[15:32:49.208]                 }
[15:32:49.208]                 NAMES <- toupper(removed)
[15:32:49.208]                 for (kk in seq_along(NAMES)) {
[15:32:49.208]                   name <- removed[[kk]]
[15:32:49.208]                   NAME <- NAMES[[kk]]
[15:32:49.208]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.208]                     next
[15:32:49.208]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.208]                 }
[15:32:49.208]                 if (length(args) > 0) 
[15:32:49.208]                   base::do.call(base::Sys.setenv, args = args)
[15:32:49.208]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:49.208]             }
[15:32:49.208]             else {
[15:32:49.208]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:49.208]             }
[15:32:49.208]             {
[15:32:49.208]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:49.208]                   0L) {
[15:32:49.208]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:49.208]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:49.208]                   base::options(opts)
[15:32:49.208]                 }
[15:32:49.208]                 {
[15:32:49.208]                   {
[15:32:49.208]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:49.208]                     NULL
[15:32:49.208]                   }
[15:32:49.208]                   options(future.plan = NULL)
[15:32:49.208]                   if (is.na(NA_character_)) 
[15:32:49.208]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.208]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:49.208]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:49.208]                     .init = FALSE)
[15:32:49.208]                 }
[15:32:49.208]             }
[15:32:49.208]         }
[15:32:49.208]     })
[15:32:49.208]     if (TRUE) {
[15:32:49.208]         base::sink(type = "output", split = FALSE)
[15:32:49.208]         if (TRUE) {
[15:32:49.208]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:49.208]         }
[15:32:49.208]         else {
[15:32:49.208]             ...future.result["stdout"] <- base::list(NULL)
[15:32:49.208]         }
[15:32:49.208]         base::close(...future.stdout)
[15:32:49.208]         ...future.stdout <- NULL
[15:32:49.208]     }
[15:32:49.208]     ...future.result$conditions <- ...future.conditions
[15:32:49.208]     ...future.result$finished <- base::Sys.time()
[15:32:49.208]     ...future.result
[15:32:49.208] }
[15:32:49.217] Exporting 11 global objects (93.29 KiB) to cluster node #1 ...
[15:32:49.218] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:49.219] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:49.219] Exporting 'x_FUN' (1.22 KiB) to cluster node #1 ...
[15:32:49.220] Exporting 'x_FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:49.220] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:49.221] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:49.222] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:49.223] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:49.223] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:49.224] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:49.225] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:49.226] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:49.226] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:49.227] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:49.228] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:49.228] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:49.229] Exporting '...future.elements_ii' (96 bytes) to cluster node #1 ...
[15:32:49.230] Exporting '...future.elements_ii' (96 bytes) to cluster node #1 ... DONE
[15:32:49.230] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:49.230] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:49.231] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:49.231] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:49.232] Exporting 11 global objects (93.29 KiB) to cluster node #1 ... DONE
[15:32:49.233] MultisessionFuture started
[15:32:49.233] - Launch lazy future ... done
[15:32:49.234] run() for 'MultisessionFuture' ... done
[15:32:49.234] Created future:
[15:32:49.266] receiveMessageFromWorker() for ClusterFuture ...
[15:32:49.266] - Validating connection of MultisessionFuture
[15:32:49.267] - received message: FutureResult
[15:32:49.267] - Received FutureResult
[15:32:49.268] - Erased future from FutureRegistry
[15:32:49.268] result() for ClusterFuture ...
[15:32:49.268] - result already collected: FutureResult
[15:32:49.269] result() for ClusterFuture ... done
[15:32:49.269] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:49.234] MultisessionFuture:
[15:32:49.234] Label: 'future_vapply-1'
[15:32:49.234] Expression:
[15:32:49.234] {
[15:32:49.234]     do.call(function(...) {
[15:32:49.234]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.234]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.234]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.234]             on.exit(options(oopts), add = TRUE)
[15:32:49.234]         }
[15:32:49.234]         {
[15:32:49.234]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.234]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.234]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.234]             })
[15:32:49.234]         }
[15:32:49.234]     }, args = future.call.arguments)
[15:32:49.234] }
[15:32:49.234] Lazy evaluation: FALSE
[15:32:49.234] Asynchronous evaluation: TRUE
[15:32:49.234] Local evaluation: TRUE
[15:32:49.234] Environment: R_GlobalEnv
[15:32:49.234] Capture standard output: TRUE
[15:32:49.234] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:49.234] Globals: 11 objects totaling 93.38 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 1.22 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:49.234] Packages: 2 packages ('stats', 'future.apply')
[15:32:49.234] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:49.234] Resolved: TRUE
[15:32:49.234] Value: <not collected>
[15:32:49.234] Conditions captured: <none>
[15:32:49.234] Early signaling: FALSE
[15:32:49.234] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:49.234] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.270] Chunk #1 of 2 ... DONE
[15:32:49.271] Chunk #2 of 2 ...
[15:32:49.271]  - Finding globals in 'X' for chunk #2 ...
[15:32:49.271] getGlobalsAndPackages() ...
[15:32:49.272] Searching for globals...
[15:32:49.272] 
[15:32:49.273] Searching for globals ... DONE
[15:32:49.273] - globals: [0] <none>
[15:32:49.273] getGlobalsAndPackages() ... DONE
[15:32:49.274]    + additional globals found: [n=0] 
[15:32:49.274]    + additional namespaces needed: [n=0] 
[15:32:49.275]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:49.275]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:49.275]  - seeds: <none>
[15:32:49.276]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.276] getGlobalsAndPackages() ...
[15:32:49.276] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.277] Resolving globals: FALSE
[15:32:49.277] Tweak future expression to call with '...' arguments ...
[15:32:49.278] {
[15:32:49.278]     do.call(function(...) {
[15:32:49.278]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.278]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.278]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.278]             on.exit(options(oopts), add = TRUE)
[15:32:49.278]         }
[15:32:49.278]         {
[15:32:49.278]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.278]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.278]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.278]             })
[15:32:49.278]         }
[15:32:49.278]     }, args = future.call.arguments)
[15:32:49.278] }
[15:32:49.278] Tweak future expression to call with '...' arguments ... DONE
[15:32:49.280] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.280] - packages: [2] 'stats', 'future.apply'
[15:32:49.281] getGlobalsAndPackages() ... DONE
[15:32:49.281] run() for 'Future' ...
[15:32:49.282] - state: 'created'
[15:32:49.282] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:49.304] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.305] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:49.305]   - Field: 'node'
[15:32:49.306]   - Field: 'label'
[15:32:49.306]   - Field: 'local'
[15:32:49.307]   - Field: 'owner'
[15:32:49.307]   - Field: 'envir'
[15:32:49.307]   - Field: 'workers'
[15:32:49.308]   - Field: 'packages'
[15:32:49.308]   - Field: 'gc'
[15:32:49.308]   - Field: 'conditions'
[15:32:49.309]   - Field: 'persistent'
[15:32:49.309]   - Field: 'expr'
[15:32:49.309]   - Field: 'uuid'
[15:32:49.310]   - Field: 'seed'
[15:32:49.310]   - Field: 'version'
[15:32:49.315]   - Field: 'result'
[15:32:49.315]   - Field: 'asynchronous'
[15:32:49.315]   - Field: 'calls'
[15:32:49.316]   - Field: 'globals'
[15:32:49.316]   - Field: 'stdout'
[15:32:49.317]   - Field: 'earlySignal'
[15:32:49.317]   - Field: 'lazy'
[15:32:49.317]   - Field: 'state'
[15:32:49.318] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:49.318] - Launch lazy future ...
[15:32:49.319] Packages needed by the future expression (n = 2): 'stats', 'future.apply'
[15:32:49.319] Packages needed by future strategies (n = 0): <none>
[15:32:49.321] {
[15:32:49.321]     {
[15:32:49.321]         {
[15:32:49.321]             ...future.startTime <- base::Sys.time()
[15:32:49.321]             {
[15:32:49.321]                 {
[15:32:49.321]                   {
[15:32:49.321]                     {
[15:32:49.321]                       {
[15:32:49.321]                         base::local({
[15:32:49.321]                           has_future <- base::requireNamespace("future", 
[15:32:49.321]                             quietly = TRUE)
[15:32:49.321]                           if (has_future) {
[15:32:49.321]                             ns <- base::getNamespace("future")
[15:32:49.321]                             version <- ns[[".package"]][["version"]]
[15:32:49.321]                             if (is.null(version)) 
[15:32:49.321]                               version <- utils::packageVersion("future")
[15:32:49.321]                           }
[15:32:49.321]                           else {
[15:32:49.321]                             version <- NULL
[15:32:49.321]                           }
[15:32:49.321]                           if (!has_future || version < "1.8.0") {
[15:32:49.321]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:49.321]                               "", base::R.version$version.string), 
[15:32:49.321]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:49.321]                                 base::R.version$platform, 8 * 
[15:32:49.321]                                   base::.Machine$sizeof.pointer), 
[15:32:49.321]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:49.321]                                 "release", "version")], collapse = " "), 
[15:32:49.321]                               hostname = base::Sys.info()[["nodename"]])
[15:32:49.321]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:49.321]                               info)
[15:32:49.321]                             info <- base::paste(info, collapse = "; ")
[15:32:49.321]                             if (!has_future) {
[15:32:49.321]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:49.321]                                 info)
[15:32:49.321]                             }
[15:32:49.321]                             else {
[15:32:49.321]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:49.321]                                 info, version)
[15:32:49.321]                             }
[15:32:49.321]                             base::stop(msg)
[15:32:49.321]                           }
[15:32:49.321]                         })
[15:32:49.321]                       }
[15:32:49.321]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:49.321]                       base::options(mc.cores = 1L)
[15:32:49.321]                     }
[15:32:49.321]                     base::local({
[15:32:49.321]                       for (pkg in c("stats", "future.apply")) {
[15:32:49.321]                         base::loadNamespace(pkg)
[15:32:49.321]                         base::library(pkg, character.only = TRUE)
[15:32:49.321]                       }
[15:32:49.321]                     })
[15:32:49.321]                   }
[15:32:49.321]                   ...future.strategy.old <- future::plan("list")
[15:32:49.321]                   options(future.plan = NULL)
[15:32:49.321]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.321]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:49.321]                 }
[15:32:49.321]                 ...future.workdir <- getwd()
[15:32:49.321]             }
[15:32:49.321]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:49.321]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:49.321]         }
[15:32:49.321]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:49.321]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:49.321]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:49.321]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:49.321]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:49.321]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:49.321]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:49.321]             base::names(...future.oldOptions))
[15:32:49.321]     }
[15:32:49.321]     if (FALSE) {
[15:32:49.321]     }
[15:32:49.321]     else {
[15:32:49.321]         if (TRUE) {
[15:32:49.321]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:49.321]                 open = "w")
[15:32:49.321]         }
[15:32:49.321]         else {
[15:32:49.321]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:49.321]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:49.321]         }
[15:32:49.321]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:49.321]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:49.321]             base::sink(type = "output", split = FALSE)
[15:32:49.321]             base::close(...future.stdout)
[15:32:49.321]         }, add = TRUE)
[15:32:49.321]     }
[15:32:49.321]     ...future.frame <- base::sys.nframe()
[15:32:49.321]     ...future.conditions <- base::list()
[15:32:49.321]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:49.321]     if (FALSE) {
[15:32:49.321]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:49.321]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:49.321]     }
[15:32:49.321]     ...future.result <- base::tryCatch({
[15:32:49.321]         base::withCallingHandlers({
[15:32:49.321]             ...future.value <- base::withVisible(base::local({
[15:32:49.321]                 ...future.makeSendCondition <- base::local({
[15:32:49.321]                   sendCondition <- NULL
[15:32:49.321]                   function(frame = 1L) {
[15:32:49.321]                     if (is.function(sendCondition)) 
[15:32:49.321]                       return(sendCondition)
[15:32:49.321]                     ns <- getNamespace("parallel")
[15:32:49.321]                     if (exists("sendData", mode = "function", 
[15:32:49.321]                       envir = ns)) {
[15:32:49.321]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:49.321]                         envir = ns)
[15:32:49.321]                       envir <- sys.frame(frame)
[15:32:49.321]                       master <- NULL
[15:32:49.321]                       while (!identical(envir, .GlobalEnv) && 
[15:32:49.321]                         !identical(envir, emptyenv())) {
[15:32:49.321]                         if (exists("master", mode = "list", envir = envir, 
[15:32:49.321]                           inherits = FALSE)) {
[15:32:49.321]                           master <- get("master", mode = "list", 
[15:32:49.321]                             envir = envir, inherits = FALSE)
[15:32:49.321]                           if (inherits(master, c("SOCKnode", 
[15:32:49.321]                             "SOCK0node"))) {
[15:32:49.321]                             sendCondition <<- function(cond) {
[15:32:49.321]                               data <- list(type = "VALUE", value = cond, 
[15:32:49.321]                                 success = TRUE)
[15:32:49.321]                               parallel_sendData(master, data)
[15:32:49.321]                             }
[15:32:49.321]                             return(sendCondition)
[15:32:49.321]                           }
[15:32:49.321]                         }
[15:32:49.321]                         frame <- frame + 1L
[15:32:49.321]                         envir <- sys.frame(frame)
[15:32:49.321]                       }
[15:32:49.321]                     }
[15:32:49.321]                     sendCondition <<- function(cond) NULL
[15:32:49.321]                   }
[15:32:49.321]                 })
[15:32:49.321]                 withCallingHandlers({
[15:32:49.321]                   {
[15:32:49.321]                     do.call(function(...) {
[15:32:49.321]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.321]                       if (!identical(...future.globals.maxSize.org, 
[15:32:49.321]                         ...future.globals.maxSize)) {
[15:32:49.321]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.321]                         on.exit(options(oopts), add = TRUE)
[15:32:49.321]                       }
[15:32:49.321]                       {
[15:32:49.321]                         lapply(seq_along(...future.elements_ii), 
[15:32:49.321]                           FUN = function(jj) {
[15:32:49.321]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.321]                             ...future.FUN(...future.X_jj, ...)
[15:32:49.321]                           })
[15:32:49.321]                       }
[15:32:49.321]                     }, args = future.call.arguments)
[15:32:49.321]                   }
[15:32:49.321]                 }, immediateCondition = function(cond) {
[15:32:49.321]                   sendCondition <- ...future.makeSendCondition()
[15:32:49.321]                   sendCondition(cond)
[15:32:49.321]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.321]                   {
[15:32:49.321]                     inherits <- base::inherits
[15:32:49.321]                     invokeRestart <- base::invokeRestart
[15:32:49.321]                     is.null <- base::is.null
[15:32:49.321]                     muffled <- FALSE
[15:32:49.321]                     if (inherits(cond, "message")) {
[15:32:49.321]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:49.321]                       if (muffled) 
[15:32:49.321]                         invokeRestart("muffleMessage")
[15:32:49.321]                     }
[15:32:49.321]                     else if (inherits(cond, "warning")) {
[15:32:49.321]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:49.321]                       if (muffled) 
[15:32:49.321]                         invokeRestart("muffleWarning")
[15:32:49.321]                     }
[15:32:49.321]                     else if (inherits(cond, "condition")) {
[15:32:49.321]                       if (!is.null(pattern)) {
[15:32:49.321]                         computeRestarts <- base::computeRestarts
[15:32:49.321]                         grepl <- base::grepl
[15:32:49.321]                         restarts <- computeRestarts(cond)
[15:32:49.321]                         for (restart in restarts) {
[15:32:49.321]                           name <- restart$name
[15:32:49.321]                           if (is.null(name)) 
[15:32:49.321]                             next
[15:32:49.321]                           if (!grepl(pattern, name)) 
[15:32:49.321]                             next
[15:32:49.321]                           invokeRestart(restart)
[15:32:49.321]                           muffled <- TRUE
[15:32:49.321]                           break
[15:32:49.321]                         }
[15:32:49.321]                       }
[15:32:49.321]                     }
[15:32:49.321]                     invisible(muffled)
[15:32:49.321]                   }
[15:32:49.321]                   muffleCondition(cond)
[15:32:49.321]                 })
[15:32:49.321]             }))
[15:32:49.321]             future::FutureResult(value = ...future.value$value, 
[15:32:49.321]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.321]                   ...future.rng), globalenv = if (FALSE) 
[15:32:49.321]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:49.321]                     ...future.globalenv.names))
[15:32:49.321]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:49.321]         }, condition = base::local({
[15:32:49.321]             c <- base::c
[15:32:49.321]             inherits <- base::inherits
[15:32:49.321]             invokeRestart <- base::invokeRestart
[15:32:49.321]             length <- base::length
[15:32:49.321]             list <- base::list
[15:32:49.321]             seq.int <- base::seq.int
[15:32:49.321]             signalCondition <- base::signalCondition
[15:32:49.321]             sys.calls <- base::sys.calls
[15:32:49.321]             `[[` <- base::`[[`
[15:32:49.321]             `+` <- base::`+`
[15:32:49.321]             `<<-` <- base::`<<-`
[15:32:49.321]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:49.321]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:49.321]                   3L)]
[15:32:49.321]             }
[15:32:49.321]             function(cond) {
[15:32:49.321]                 is_error <- inherits(cond, "error")
[15:32:49.321]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:49.321]                   NULL)
[15:32:49.321]                 if (is_error) {
[15:32:49.321]                   sessionInformation <- function() {
[15:32:49.321]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:49.321]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:49.321]                       search = base::search(), system = base::Sys.info())
[15:32:49.321]                   }
[15:32:49.321]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.321]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:49.321]                     cond$call), session = sessionInformation(), 
[15:32:49.321]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:49.321]                   signalCondition(cond)
[15:32:49.321]                 }
[15:32:49.321]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:49.321]                 "immediateCondition"))) {
[15:32:49.321]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:49.321]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.321]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:49.321]                   if (TRUE && !signal) {
[15:32:49.321]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.321]                     {
[15:32:49.321]                       inherits <- base::inherits
[15:32:49.321]                       invokeRestart <- base::invokeRestart
[15:32:49.321]                       is.null <- base::is.null
[15:32:49.321]                       muffled <- FALSE
[15:32:49.321]                       if (inherits(cond, "message")) {
[15:32:49.321]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.321]                         if (muffled) 
[15:32:49.321]                           invokeRestart("muffleMessage")
[15:32:49.321]                       }
[15:32:49.321]                       else if (inherits(cond, "warning")) {
[15:32:49.321]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.321]                         if (muffled) 
[15:32:49.321]                           invokeRestart("muffleWarning")
[15:32:49.321]                       }
[15:32:49.321]                       else if (inherits(cond, "condition")) {
[15:32:49.321]                         if (!is.null(pattern)) {
[15:32:49.321]                           computeRestarts <- base::computeRestarts
[15:32:49.321]                           grepl <- base::grepl
[15:32:49.321]                           restarts <- computeRestarts(cond)
[15:32:49.321]                           for (restart in restarts) {
[15:32:49.321]                             name <- restart$name
[15:32:49.321]                             if (is.null(name)) 
[15:32:49.321]                               next
[15:32:49.321]                             if (!grepl(pattern, name)) 
[15:32:49.321]                               next
[15:32:49.321]                             invokeRestart(restart)
[15:32:49.321]                             muffled <- TRUE
[15:32:49.321]                             break
[15:32:49.321]                           }
[15:32:49.321]                         }
[15:32:49.321]                       }
[15:32:49.321]                       invisible(muffled)
[15:32:49.321]                     }
[15:32:49.321]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.321]                   }
[15:32:49.321]                 }
[15:32:49.321]                 else {
[15:32:49.321]                   if (TRUE) {
[15:32:49.321]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.321]                     {
[15:32:49.321]                       inherits <- base::inherits
[15:32:49.321]                       invokeRestart <- base::invokeRestart
[15:32:49.321]                       is.null <- base::is.null
[15:32:49.321]                       muffled <- FALSE
[15:32:49.321]                       if (inherits(cond, "message")) {
[15:32:49.321]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.321]                         if (muffled) 
[15:32:49.321]                           invokeRestart("muffleMessage")
[15:32:49.321]                       }
[15:32:49.321]                       else if (inherits(cond, "warning")) {
[15:32:49.321]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.321]                         if (muffled) 
[15:32:49.321]                           invokeRestart("muffleWarning")
[15:32:49.321]                       }
[15:32:49.321]                       else if (inherits(cond, "condition")) {
[15:32:49.321]                         if (!is.null(pattern)) {
[15:32:49.321]                           computeRestarts <- base::computeRestarts
[15:32:49.321]                           grepl <- base::grepl
[15:32:49.321]                           restarts <- computeRestarts(cond)
[15:32:49.321]                           for (restart in restarts) {
[15:32:49.321]                             name <- restart$name
[15:32:49.321]                             if (is.null(name)) 
[15:32:49.321]                               next
[15:32:49.321]                             if (!grepl(pattern, name)) 
[15:32:49.321]                               next
[15:32:49.321]                             invokeRestart(restart)
[15:32:49.321]                             muffled <- TRUE
[15:32:49.321]                             break
[15:32:49.321]                           }
[15:32:49.321]                         }
[15:32:49.321]                       }
[15:32:49.321]                       invisible(muffled)
[15:32:49.321]                     }
[15:32:49.321]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.321]                   }
[15:32:49.321]                 }
[15:32:49.321]             }
[15:32:49.321]         }))
[15:32:49.321]     }, error = function(ex) {
[15:32:49.321]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:49.321]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.321]                 ...future.rng), started = ...future.startTime, 
[15:32:49.321]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:49.321]             version = "1.8"), class = "FutureResult")
[15:32:49.321]     }, finally = {
[15:32:49.321]         if (!identical(...future.workdir, getwd())) 
[15:32:49.321]             setwd(...future.workdir)
[15:32:49.321]         {
[15:32:49.321]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:49.321]                 ...future.oldOptions$nwarnings <- NULL
[15:32:49.321]             }
[15:32:49.321]             base::options(...future.oldOptions)
[15:32:49.321]             if (.Platform$OS.type == "windows") {
[15:32:49.321]                 old_names <- names(...future.oldEnvVars)
[15:32:49.321]                 envs <- base::Sys.getenv()
[15:32:49.321]                 names <- names(envs)
[15:32:49.321]                 common <- intersect(names, old_names)
[15:32:49.321]                 added <- setdiff(names, old_names)
[15:32:49.321]                 removed <- setdiff(old_names, names)
[15:32:49.321]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:49.321]                   envs[common]]
[15:32:49.321]                 NAMES <- toupper(changed)
[15:32:49.321]                 args <- list()
[15:32:49.321]                 for (kk in seq_along(NAMES)) {
[15:32:49.321]                   name <- changed[[kk]]
[15:32:49.321]                   NAME <- NAMES[[kk]]
[15:32:49.321]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.321]                     next
[15:32:49.321]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.321]                 }
[15:32:49.321]                 NAMES <- toupper(added)
[15:32:49.321]                 for (kk in seq_along(NAMES)) {
[15:32:49.321]                   name <- added[[kk]]
[15:32:49.321]                   NAME <- NAMES[[kk]]
[15:32:49.321]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.321]                     next
[15:32:49.321]                   args[[name]] <- ""
[15:32:49.321]                 }
[15:32:49.321]                 NAMES <- toupper(removed)
[15:32:49.321]                 for (kk in seq_along(NAMES)) {
[15:32:49.321]                   name <- removed[[kk]]
[15:32:49.321]                   NAME <- NAMES[[kk]]
[15:32:49.321]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.321]                     next
[15:32:49.321]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.321]                 }
[15:32:49.321]                 if (length(args) > 0) 
[15:32:49.321]                   base::do.call(base::Sys.setenv, args = args)
[15:32:49.321]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:49.321]             }
[15:32:49.321]             else {
[15:32:49.321]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:49.321]             }
[15:32:49.321]             {
[15:32:49.321]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:49.321]                   0L) {
[15:32:49.321]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:49.321]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:49.321]                   base::options(opts)
[15:32:49.321]                 }
[15:32:49.321]                 {
[15:32:49.321]                   {
[15:32:49.321]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:49.321]                     NULL
[15:32:49.321]                   }
[15:32:49.321]                   options(future.plan = NULL)
[15:32:49.321]                   if (is.na(NA_character_)) 
[15:32:49.321]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.321]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:49.321]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:49.321]                     .init = FALSE)
[15:32:49.321]                 }
[15:32:49.321]             }
[15:32:49.321]         }
[15:32:49.321]     })
[15:32:49.321]     if (TRUE) {
[15:32:49.321]         base::sink(type = "output", split = FALSE)
[15:32:49.321]         if (TRUE) {
[15:32:49.321]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:49.321]         }
[15:32:49.321]         else {
[15:32:49.321]             ...future.result["stdout"] <- base::list(NULL)
[15:32:49.321]         }
[15:32:49.321]         base::close(...future.stdout)
[15:32:49.321]         ...future.stdout <- NULL
[15:32:49.321]     }
[15:32:49.321]     ...future.result$conditions <- ...future.conditions
[15:32:49.321]     ...future.result$finished <- base::Sys.time()
[15:32:49.321]     ...future.result
[15:32:49.321] }
[15:32:49.332] Exporting 11 global objects (93.29 KiB) to cluster node #1 ...
[15:32:49.332] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:49.333] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:49.334] Exporting 'x_FUN' (1.22 KiB) to cluster node #1 ...
[15:32:49.335] Exporting 'x_FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:32:49.335] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:49.336] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:49.336] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:49.337] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:49.337] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:49.338] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:49.339] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:49.339] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:49.340] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:49.340] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:49.341] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:49.342] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:49.342] Exporting '...future.elements_ii' (176 bytes) to cluster node #1 ...
[15:32:49.343] Exporting '...future.elements_ii' (176 bytes) to cluster node #1 ... DONE
[15:32:49.343] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:49.344] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:49.345] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:49.346] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:49.346] Exporting 11 global objects (93.29 KiB) to cluster node #1 ... DONE
[15:32:49.347] MultisessionFuture started
[15:32:49.347] - Launch lazy future ... done
[15:32:49.348] run() for 'MultisessionFuture' ... done
[15:32:49.348] Created future:
[15:32:49.381] receiveMessageFromWorker() for ClusterFuture ...
[15:32:49.382] - Validating connection of MultisessionFuture
[15:32:49.382] - received message: FutureResult
[15:32:49.382] - Received FutureResult
[15:32:49.383] - Erased future from FutureRegistry
[15:32:49.383] result() for ClusterFuture ...
[15:32:49.383] - result already collected: FutureResult
[15:32:49.383] result() for ClusterFuture ... done
[15:32:49.383] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:49.348] MultisessionFuture:
[15:32:49.348] Label: 'future_vapply-2'
[15:32:49.348] Expression:
[15:32:49.348] {
[15:32:49.348]     do.call(function(...) {
[15:32:49.348]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.348]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.348]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.348]             on.exit(options(oopts), add = TRUE)
[15:32:49.348]         }
[15:32:49.348]         {
[15:32:49.348]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.348]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.348]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.348]             })
[15:32:49.348]         }
[15:32:49.348]     }, args = future.call.arguments)
[15:32:49.348] }
[15:32:49.348] Lazy evaluation: FALSE
[15:32:49.348] Asynchronous evaluation: TRUE
[15:32:49.348] Local evaluation: TRUE
[15:32:49.348] Environment: R_GlobalEnv
[15:32:49.348] Capture standard output: TRUE
[15:32:49.348] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:49.348] Globals: 11 objects totaling 93.46 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 1.22 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:49.348] Packages: 2 packages ('stats', 'future.apply')
[15:32:49.348] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:49.348] Resolved: TRUE
[15:32:49.348] Value: <not collected>
[15:32:49.348] Conditions captured: <none>
[15:32:49.348] Early signaling: FALSE
[15:32:49.348] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:49.348] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.384] Chunk #2 of 2 ... DONE
[15:32:49.384] Launching 2 futures (chunks) ... DONE
[15:32:49.384] Resolving 2 futures (chunks) ...
[15:32:49.384] resolve() on list ...
[15:32:49.384]  recursive: 0
[15:32:49.385]  length: 2
[15:32:49.385] 
[15:32:49.385] Future #1
[15:32:49.385] result() for ClusterFuture ...
[15:32:49.385] - result already collected: FutureResult
[15:32:49.386] result() for ClusterFuture ... done
[15:32:49.386] result() for ClusterFuture ...
[15:32:49.386] - result already collected: FutureResult
[15:32:49.386] result() for ClusterFuture ... done
[15:32:49.386] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:49.386] - nx: 2
[15:32:49.387] - relay: TRUE
[15:32:49.387] - stdout: TRUE
[15:32:49.387] - signal: TRUE
[15:32:49.387] - resignal: FALSE
[15:32:49.387] - force: TRUE
[15:32:49.387] - relayed: [n=2] FALSE, FALSE
[15:32:49.387] - queued futures: [n=2] FALSE, FALSE
[15:32:49.388]  - until=1
[15:32:49.388]  - relaying element #1
[15:32:49.388] result() for ClusterFuture ...
[15:32:49.388] - result already collected: FutureResult
[15:32:49.388] result() for ClusterFuture ... done
[15:32:49.389] result() for ClusterFuture ...
[15:32:49.389] - result already collected: FutureResult
[15:32:49.389] result() for ClusterFuture ... done
[15:32:49.389] result() for ClusterFuture ...
[15:32:49.389] - result already collected: FutureResult
[15:32:49.389] result() for ClusterFuture ... done
[15:32:49.390] result() for ClusterFuture ...
[15:32:49.390] - result already collected: FutureResult
[15:32:49.390] result() for ClusterFuture ... done
[15:32:49.390] - relayed: [n=2] TRUE, FALSE
[15:32:49.390] - queued futures: [n=2] TRUE, FALSE
[15:32:49.390] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:49.391]  length: 1 (resolved future 1)
[15:32:49.391] Future #2
[15:32:49.391] result() for ClusterFuture ...
[15:32:49.391] - result already collected: FutureResult
[15:32:49.391] result() for ClusterFuture ... done
[15:32:49.392] result() for ClusterFuture ...
[15:32:49.392] - result already collected: FutureResult
[15:32:49.392] result() for ClusterFuture ... done
[15:32:49.392] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:49.392] - nx: 2
[15:32:49.392] - relay: TRUE
[15:32:49.393] - stdout: TRUE
[15:32:49.393] - signal: TRUE
[15:32:49.393] - resignal: FALSE
[15:32:49.393] - force: TRUE
[15:32:49.393] - relayed: [n=2] TRUE, FALSE
[15:32:49.393] - queued futures: [n=2] TRUE, FALSE
[15:32:49.393]  - until=2
[15:32:49.394]  - relaying element #2
[15:32:49.394] result() for ClusterFuture ...
[15:32:49.394] - result already collected: FutureResult
[15:32:49.394] result() for ClusterFuture ... done
[15:32:49.394] result() for ClusterFuture ...
[15:32:49.394] - result already collected: FutureResult
[15:32:49.395] result() for ClusterFuture ... done
[15:32:49.395] result() for ClusterFuture ...
[15:32:49.395] - result already collected: FutureResult
[15:32:49.395] result() for ClusterFuture ... done
[15:32:49.395] result() for ClusterFuture ...
[15:32:49.395] - result already collected: FutureResult
[15:32:49.396] result() for ClusterFuture ... done
[15:32:49.396] - relayed: [n=2] TRUE, TRUE
[15:32:49.396] - queued futures: [n=2] TRUE, TRUE
[15:32:49.396] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:49.397]  length: 0 (resolved future 2)
[15:32:49.397] Relaying remaining futures
[15:32:49.397] signalConditionsASAP(NULL, pos=0) ...
[15:32:49.397] - nx: 2
[15:32:49.397] - relay: TRUE
[15:32:49.397] - stdout: TRUE
[15:32:49.398] - signal: TRUE
[15:32:49.398] - resignal: FALSE
[15:32:49.398] - force: TRUE
[15:32:49.398] - relayed: [n=2] TRUE, TRUE
[15:32:49.398] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:49.398] - relayed: [n=2] TRUE, TRUE
[15:32:49.399] - queued futures: [n=2] TRUE, TRUE
[15:32:49.399] signalConditionsASAP(NULL, pos=0) ... done
[15:32:49.399] resolve() on list ... DONE
[15:32:49.399] result() for ClusterFuture ...
[15:32:49.399] - result already collected: FutureResult
[15:32:49.399] result() for ClusterFuture ... done
[15:32:49.400] result() for ClusterFuture ...
[15:32:49.400] - result already collected: FutureResult
[15:32:49.400] result() for ClusterFuture ... done
[15:32:49.400] result() for ClusterFuture ...
[15:32:49.400] - result already collected: FutureResult
[15:32:49.400] result() for ClusterFuture ... done
[15:32:49.401] result() for ClusterFuture ...
[15:32:49.401] - result already collected: FutureResult
[15:32:49.401] result() for ClusterFuture ... done
[15:32:49.401]  - Number of value chunks collected: 2
[15:32:49.401] Resolving 2 futures (chunks) ... DONE
[15:32:49.401] Reducing values from 2 chunks ...
[15:32:49.402]  - Number of values collected after concatenation: 3
[15:32:49.402]  - Number of values expected: 3
[15:32:49.402] Reducing values from 2 chunks ... DONE
[15:32:49.402] future_lapply() ... DONE
 num [1:5, 1:3] 1 3.25 5.5 7.75 10 ...
 - attr(*, "dimnames")=List of 2
  ..$ : chr [1:5] "0%" "25%" "50%" "75%" ...
  ..$ : chr [1:3] "a" "beta" "logic"
[15:32:49.405] future_lapply() ...
[15:32:49.413] Number of chunks: 2
[15:32:49.414] getGlobalsAndPackagesXApply() ...
[15:32:49.414]  - future.globals: TRUE
[15:32:49.414] getGlobalsAndPackages() ...
[15:32:49.414] Searching for globals...
[15:32:49.423] - globals found: [21] 'FUN', '{', '<-', 'is.na', 'if', 'any', '[', '!', 'return', 'rep.int', 'sort', 'length', '==', '/', 'floor', '(', '+', 'c', '-', '*', 'ceiling'
[15:32:49.423] Searching for globals ... DONE
[15:32:49.424] Resolving globals: FALSE
[15:32:49.426] The total size of the 1 globals is 45.86 KiB (46960 bytes)
[15:32:49.426] The total size of the 1 globals exported for future expression ('FUN()') is 45.86 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (45.86 KiB of class 'function')
[15:32:49.427] - globals: [1] 'FUN'
[15:32:49.427] - packages: [1] 'stats'
[15:32:49.427] getGlobalsAndPackages() ... DONE
[15:32:49.428]  - globals found/used: [n=1] 'FUN'
[15:32:49.428]  - needed namespaces: [n=1] 'stats'
[15:32:49.428] Finding globals ... DONE
[15:32:49.429]  - use_args: TRUE
[15:32:49.429]  - Getting '...' globals ...
[15:32:49.430] resolve() on list ...
[15:32:49.430]  recursive: 0
[15:32:49.430]  length: 1
[15:32:49.430]  elements: '...'
[15:32:49.431]  length: 0 (resolved future 1)
[15:32:49.431] resolve() on list ... DONE
[15:32:49.431]    - '...' content: [n=0] 
[15:32:49.432] List of 1
[15:32:49.432]  $ ...: list()
[15:32:49.432]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:49.432]  - attr(*, "where")=List of 1
[15:32:49.432]   ..$ ...:<environment: 0x0000022d4006ea38> 
[15:32:49.432]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:49.432]  - attr(*, "resolved")= logi TRUE
[15:32:49.432]  - attr(*, "total_size")= num NA
[15:32:49.437]  - Getting '...' globals ... DONE
[15:32:49.437] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:49.437] List of 2
[15:32:49.437]  $ ...future.FUN:function (x, na.rm = TRUE)  
[15:32:49.437]  $ ...          : list()
[15:32:49.437]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:49.437]  - attr(*, "where")=List of 2
[15:32:49.437]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:49.437]   ..$ ...          :<environment: 0x0000022d4006ea38> 
[15:32:49.437]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:49.437]  - attr(*, "resolved")= logi FALSE
[15:32:49.437]  - attr(*, "total_size")= num 46960
[15:32:49.443] Packages to be attached in all futures: [n=1] 'stats'
[15:32:49.443] getGlobalsAndPackagesXApply() ... DONE
[15:32:49.444] Number of futures (= number of chunks): 2
[15:32:49.444] Launching 2 futures (chunks) ...
[15:32:49.444] Chunk #1 of 2 ...
[15:32:49.445]  - Finding globals in 'X' for chunk #1 ...
[15:32:49.445] getGlobalsAndPackages() ...
[15:32:49.445] Searching for globals...
[15:32:49.446] 
[15:32:49.446] Searching for globals ... DONE
[15:32:49.446] - globals: [0] <none>
[15:32:49.447] getGlobalsAndPackages() ... DONE
[15:32:49.447]    + additional globals found: [n=0] 
[15:32:49.447]    + additional namespaces needed: [n=0] 
[15:32:49.447]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:49.448]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:49.448]  - seeds: <none>
[15:32:49.448]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.449] getGlobalsAndPackages() ...
[15:32:49.449] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.449] Resolving globals: FALSE
[15:32:49.450] Tweak future expression to call with '...' arguments ...
[15:32:49.450] {
[15:32:49.450]     do.call(function(...) {
[15:32:49.450]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.450]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.450]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.450]             on.exit(options(oopts), add = TRUE)
[15:32:49.450]         }
[15:32:49.450]         {
[15:32:49.450]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.450]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.450]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.450]             })
[15:32:49.450]         }
[15:32:49.450]     }, args = future.call.arguments)
[15:32:49.450] }
[15:32:49.451] Tweak future expression to call with '...' arguments ... DONE
[15:32:49.451] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.452] - packages: [1] 'stats'
[15:32:49.452] getGlobalsAndPackages() ... DONE
[15:32:49.453] run() for 'Future' ...
[15:32:49.453] - state: 'created'
[15:32:49.454] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:49.472] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.472] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:49.473]   - Field: 'node'
[15:32:49.473]   - Field: 'label'
[15:32:49.473]   - Field: 'local'
[15:32:49.474]   - Field: 'owner'
[15:32:49.474]   - Field: 'envir'
[15:32:49.474]   - Field: 'workers'
[15:32:49.475]   - Field: 'packages'
[15:32:49.475]   - Field: 'gc'
[15:32:49.475]   - Field: 'conditions'
[15:32:49.476]   - Field: 'persistent'
[15:32:49.476]   - Field: 'expr'
[15:32:49.476]   - Field: 'uuid'
[15:32:49.477]   - Field: 'seed'
[15:32:49.477]   - Field: 'version'
[15:32:49.477]   - Field: 'result'
[15:32:49.478]   - Field: 'asynchronous'
[15:32:49.478]   - Field: 'calls'
[15:32:49.478]   - Field: 'globals'
[15:32:49.478]   - Field: 'stdout'
[15:32:49.479]   - Field: 'earlySignal'
[15:32:49.479]   - Field: 'lazy'
[15:32:49.479]   - Field: 'state'
[15:32:49.480] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:49.480] - Launch lazy future ...
[15:32:49.481] Packages needed by the future expression (n = 1): 'stats'
[15:32:49.481] Packages needed by future strategies (n = 0): <none>
[15:32:49.482] {
[15:32:49.482]     {
[15:32:49.482]         {
[15:32:49.482]             ...future.startTime <- base::Sys.time()
[15:32:49.482]             {
[15:32:49.482]                 {
[15:32:49.482]                   {
[15:32:49.482]                     {
[15:32:49.482]                       {
[15:32:49.482]                         base::local({
[15:32:49.482]                           has_future <- base::requireNamespace("future", 
[15:32:49.482]                             quietly = TRUE)
[15:32:49.482]                           if (has_future) {
[15:32:49.482]                             ns <- base::getNamespace("future")
[15:32:49.482]                             version <- ns[[".package"]][["version"]]
[15:32:49.482]                             if (is.null(version)) 
[15:32:49.482]                               version <- utils::packageVersion("future")
[15:32:49.482]                           }
[15:32:49.482]                           else {
[15:32:49.482]                             version <- NULL
[15:32:49.482]                           }
[15:32:49.482]                           if (!has_future || version < "1.8.0") {
[15:32:49.482]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:49.482]                               "", base::R.version$version.string), 
[15:32:49.482]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:49.482]                                 base::R.version$platform, 8 * 
[15:32:49.482]                                   base::.Machine$sizeof.pointer), 
[15:32:49.482]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:49.482]                                 "release", "version")], collapse = " "), 
[15:32:49.482]                               hostname = base::Sys.info()[["nodename"]])
[15:32:49.482]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:49.482]                               info)
[15:32:49.482]                             info <- base::paste(info, collapse = "; ")
[15:32:49.482]                             if (!has_future) {
[15:32:49.482]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:49.482]                                 info)
[15:32:49.482]                             }
[15:32:49.482]                             else {
[15:32:49.482]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:49.482]                                 info, version)
[15:32:49.482]                             }
[15:32:49.482]                             base::stop(msg)
[15:32:49.482]                           }
[15:32:49.482]                         })
[15:32:49.482]                       }
[15:32:49.482]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:49.482]                       base::options(mc.cores = 1L)
[15:32:49.482]                     }
[15:32:49.482]                     base::local({
[15:32:49.482]                       for (pkg in "stats") {
[15:32:49.482]                         base::loadNamespace(pkg)
[15:32:49.482]                         base::library(pkg, character.only = TRUE)
[15:32:49.482]                       }
[15:32:49.482]                     })
[15:32:49.482]                   }
[15:32:49.482]                   ...future.strategy.old <- future::plan("list")
[15:32:49.482]                   options(future.plan = NULL)
[15:32:49.482]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.482]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:49.482]                 }
[15:32:49.482]                 ...future.workdir <- getwd()
[15:32:49.482]             }
[15:32:49.482]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:49.482]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:49.482]         }
[15:32:49.482]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:49.482]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:49.482]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:49.482]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:49.482]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:49.482]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:49.482]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:49.482]             base::names(...future.oldOptions))
[15:32:49.482]     }
[15:32:49.482]     if (FALSE) {
[15:32:49.482]     }
[15:32:49.482]     else {
[15:32:49.482]         if (TRUE) {
[15:32:49.482]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:49.482]                 open = "w")
[15:32:49.482]         }
[15:32:49.482]         else {
[15:32:49.482]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:49.482]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:49.482]         }
[15:32:49.482]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:49.482]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:49.482]             base::sink(type = "output", split = FALSE)
[15:32:49.482]             base::close(...future.stdout)
[15:32:49.482]         }, add = TRUE)
[15:32:49.482]     }
[15:32:49.482]     ...future.frame <- base::sys.nframe()
[15:32:49.482]     ...future.conditions <- base::list()
[15:32:49.482]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:49.482]     if (FALSE) {
[15:32:49.482]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:49.482]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:49.482]     }
[15:32:49.482]     ...future.result <- base::tryCatch({
[15:32:49.482]         base::withCallingHandlers({
[15:32:49.482]             ...future.value <- base::withVisible(base::local({
[15:32:49.482]                 ...future.makeSendCondition <- base::local({
[15:32:49.482]                   sendCondition <- NULL
[15:32:49.482]                   function(frame = 1L) {
[15:32:49.482]                     if (is.function(sendCondition)) 
[15:32:49.482]                       return(sendCondition)
[15:32:49.482]                     ns <- getNamespace("parallel")
[15:32:49.482]                     if (exists("sendData", mode = "function", 
[15:32:49.482]                       envir = ns)) {
[15:32:49.482]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:49.482]                         envir = ns)
[15:32:49.482]                       envir <- sys.frame(frame)
[15:32:49.482]                       master <- NULL
[15:32:49.482]                       while (!identical(envir, .GlobalEnv) && 
[15:32:49.482]                         !identical(envir, emptyenv())) {
[15:32:49.482]                         if (exists("master", mode = "list", envir = envir, 
[15:32:49.482]                           inherits = FALSE)) {
[15:32:49.482]                           master <- get("master", mode = "list", 
[15:32:49.482]                             envir = envir, inherits = FALSE)
[15:32:49.482]                           if (inherits(master, c("SOCKnode", 
[15:32:49.482]                             "SOCK0node"))) {
[15:32:49.482]                             sendCondition <<- function(cond) {
[15:32:49.482]                               data <- list(type = "VALUE", value = cond, 
[15:32:49.482]                                 success = TRUE)
[15:32:49.482]                               parallel_sendData(master, data)
[15:32:49.482]                             }
[15:32:49.482]                             return(sendCondition)
[15:32:49.482]                           }
[15:32:49.482]                         }
[15:32:49.482]                         frame <- frame + 1L
[15:32:49.482]                         envir <- sys.frame(frame)
[15:32:49.482]                       }
[15:32:49.482]                     }
[15:32:49.482]                     sendCondition <<- function(cond) NULL
[15:32:49.482]                   }
[15:32:49.482]                 })
[15:32:49.482]                 withCallingHandlers({
[15:32:49.482]                   {
[15:32:49.482]                     do.call(function(...) {
[15:32:49.482]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.482]                       if (!identical(...future.globals.maxSize.org, 
[15:32:49.482]                         ...future.globals.maxSize)) {
[15:32:49.482]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.482]                         on.exit(options(oopts), add = TRUE)
[15:32:49.482]                       }
[15:32:49.482]                       {
[15:32:49.482]                         lapply(seq_along(...future.elements_ii), 
[15:32:49.482]                           FUN = function(jj) {
[15:32:49.482]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.482]                             ...future.FUN(...future.X_jj, ...)
[15:32:49.482]                           })
[15:32:49.482]                       }
[15:32:49.482]                     }, args = future.call.arguments)
[15:32:49.482]                   }
[15:32:49.482]                 }, immediateCondition = function(cond) {
[15:32:49.482]                   sendCondition <- ...future.makeSendCondition()
[15:32:49.482]                   sendCondition(cond)
[15:32:49.482]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.482]                   {
[15:32:49.482]                     inherits <- base::inherits
[15:32:49.482]                     invokeRestart <- base::invokeRestart
[15:32:49.482]                     is.null <- base::is.null
[15:32:49.482]                     muffled <- FALSE
[15:32:49.482]                     if (inherits(cond, "message")) {
[15:32:49.482]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:49.482]                       if (muffled) 
[15:32:49.482]                         invokeRestart("muffleMessage")
[15:32:49.482]                     }
[15:32:49.482]                     else if (inherits(cond, "warning")) {
[15:32:49.482]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:49.482]                       if (muffled) 
[15:32:49.482]                         invokeRestart("muffleWarning")
[15:32:49.482]                     }
[15:32:49.482]                     else if (inherits(cond, "condition")) {
[15:32:49.482]                       if (!is.null(pattern)) {
[15:32:49.482]                         computeRestarts <- base::computeRestarts
[15:32:49.482]                         grepl <- base::grepl
[15:32:49.482]                         restarts <- computeRestarts(cond)
[15:32:49.482]                         for (restart in restarts) {
[15:32:49.482]                           name <- restart$name
[15:32:49.482]                           if (is.null(name)) 
[15:32:49.482]                             next
[15:32:49.482]                           if (!grepl(pattern, name)) 
[15:32:49.482]                             next
[15:32:49.482]                           invokeRestart(restart)
[15:32:49.482]                           muffled <- TRUE
[15:32:49.482]                           break
[15:32:49.482]                         }
[15:32:49.482]                       }
[15:32:49.482]                     }
[15:32:49.482]                     invisible(muffled)
[15:32:49.482]                   }
[15:32:49.482]                   muffleCondition(cond)
[15:32:49.482]                 })
[15:32:49.482]             }))
[15:32:49.482]             future::FutureResult(value = ...future.value$value, 
[15:32:49.482]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.482]                   ...future.rng), globalenv = if (FALSE) 
[15:32:49.482]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:49.482]                     ...future.globalenv.names))
[15:32:49.482]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:49.482]         }, condition = base::local({
[15:32:49.482]             c <- base::c
[15:32:49.482]             inherits <- base::inherits
[15:32:49.482]             invokeRestart <- base::invokeRestart
[15:32:49.482]             length <- base::length
[15:32:49.482]             list <- base::list
[15:32:49.482]             seq.int <- base::seq.int
[15:32:49.482]             signalCondition <- base::signalCondition
[15:32:49.482]             sys.calls <- base::sys.calls
[15:32:49.482]             `[[` <- base::`[[`
[15:32:49.482]             `+` <- base::`+`
[15:32:49.482]             `<<-` <- base::`<<-`
[15:32:49.482]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:49.482]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:49.482]                   3L)]
[15:32:49.482]             }
[15:32:49.482]             function(cond) {
[15:32:49.482]                 is_error <- inherits(cond, "error")
[15:32:49.482]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:49.482]                   NULL)
[15:32:49.482]                 if (is_error) {
[15:32:49.482]                   sessionInformation <- function() {
[15:32:49.482]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:49.482]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:49.482]                       search = base::search(), system = base::Sys.info())
[15:32:49.482]                   }
[15:32:49.482]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.482]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:49.482]                     cond$call), session = sessionInformation(), 
[15:32:49.482]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:49.482]                   signalCondition(cond)
[15:32:49.482]                 }
[15:32:49.482]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:49.482]                 "immediateCondition"))) {
[15:32:49.482]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:49.482]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.482]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:49.482]                   if (TRUE && !signal) {
[15:32:49.482]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.482]                     {
[15:32:49.482]                       inherits <- base::inherits
[15:32:49.482]                       invokeRestart <- base::invokeRestart
[15:32:49.482]                       is.null <- base::is.null
[15:32:49.482]                       muffled <- FALSE
[15:32:49.482]                       if (inherits(cond, "message")) {
[15:32:49.482]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.482]                         if (muffled) 
[15:32:49.482]                           invokeRestart("muffleMessage")
[15:32:49.482]                       }
[15:32:49.482]                       else if (inherits(cond, "warning")) {
[15:32:49.482]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.482]                         if (muffled) 
[15:32:49.482]                           invokeRestart("muffleWarning")
[15:32:49.482]                       }
[15:32:49.482]                       else if (inherits(cond, "condition")) {
[15:32:49.482]                         if (!is.null(pattern)) {
[15:32:49.482]                           computeRestarts <- base::computeRestarts
[15:32:49.482]                           grepl <- base::grepl
[15:32:49.482]                           restarts <- computeRestarts(cond)
[15:32:49.482]                           for (restart in restarts) {
[15:32:49.482]                             name <- restart$name
[15:32:49.482]                             if (is.null(name)) 
[15:32:49.482]                               next
[15:32:49.482]                             if (!grepl(pattern, name)) 
[15:32:49.482]                               next
[15:32:49.482]                             invokeRestart(restart)
[15:32:49.482]                             muffled <- TRUE
[15:32:49.482]                             break
[15:32:49.482]                           }
[15:32:49.482]                         }
[15:32:49.482]                       }
[15:32:49.482]                       invisible(muffled)
[15:32:49.482]                     }
[15:32:49.482]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.482]                   }
[15:32:49.482]                 }
[15:32:49.482]                 else {
[15:32:49.482]                   if (TRUE) {
[15:32:49.482]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.482]                     {
[15:32:49.482]                       inherits <- base::inherits
[15:32:49.482]                       invokeRestart <- base::invokeRestart
[15:32:49.482]                       is.null <- base::is.null
[15:32:49.482]                       muffled <- FALSE
[15:32:49.482]                       if (inherits(cond, "message")) {
[15:32:49.482]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.482]                         if (muffled) 
[15:32:49.482]                           invokeRestart("muffleMessage")
[15:32:49.482]                       }
[15:32:49.482]                       else if (inherits(cond, "warning")) {
[15:32:49.482]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.482]                         if (muffled) 
[15:32:49.482]                           invokeRestart("muffleWarning")
[15:32:49.482]                       }
[15:32:49.482]                       else if (inherits(cond, "condition")) {
[15:32:49.482]                         if (!is.null(pattern)) {
[15:32:49.482]                           computeRestarts <- base::computeRestarts
[15:32:49.482]                           grepl <- base::grepl
[15:32:49.482]                           restarts <- computeRestarts(cond)
[15:32:49.482]                           for (restart in restarts) {
[15:32:49.482]                             name <- restart$name
[15:32:49.482]                             if (is.null(name)) 
[15:32:49.482]                               next
[15:32:49.482]                             if (!grepl(pattern, name)) 
[15:32:49.482]                               next
[15:32:49.482]                             invokeRestart(restart)
[15:32:49.482]                             muffled <- TRUE
[15:32:49.482]                             break
[15:32:49.482]                           }
[15:32:49.482]                         }
[15:32:49.482]                       }
[15:32:49.482]                       invisible(muffled)
[15:32:49.482]                     }
[15:32:49.482]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.482]                   }
[15:32:49.482]                 }
[15:32:49.482]             }
[15:32:49.482]         }))
[15:32:49.482]     }, error = function(ex) {
[15:32:49.482]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:49.482]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.482]                 ...future.rng), started = ...future.startTime, 
[15:32:49.482]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:49.482]             version = "1.8"), class = "FutureResult")
[15:32:49.482]     }, finally = {
[15:32:49.482]         if (!identical(...future.workdir, getwd())) 
[15:32:49.482]             setwd(...future.workdir)
[15:32:49.482]         {
[15:32:49.482]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:49.482]                 ...future.oldOptions$nwarnings <- NULL
[15:32:49.482]             }
[15:32:49.482]             base::options(...future.oldOptions)
[15:32:49.482]             if (.Platform$OS.type == "windows") {
[15:32:49.482]                 old_names <- names(...future.oldEnvVars)
[15:32:49.482]                 envs <- base::Sys.getenv()
[15:32:49.482]                 names <- names(envs)
[15:32:49.482]                 common <- intersect(names, old_names)
[15:32:49.482]                 added <- setdiff(names, old_names)
[15:32:49.482]                 removed <- setdiff(old_names, names)
[15:32:49.482]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:49.482]                   envs[common]]
[15:32:49.482]                 NAMES <- toupper(changed)
[15:32:49.482]                 args <- list()
[15:32:49.482]                 for (kk in seq_along(NAMES)) {
[15:32:49.482]                   name <- changed[[kk]]
[15:32:49.482]                   NAME <- NAMES[[kk]]
[15:32:49.482]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.482]                     next
[15:32:49.482]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.482]                 }
[15:32:49.482]                 NAMES <- toupper(added)
[15:32:49.482]                 for (kk in seq_along(NAMES)) {
[15:32:49.482]                   name <- added[[kk]]
[15:32:49.482]                   NAME <- NAMES[[kk]]
[15:32:49.482]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.482]                     next
[15:32:49.482]                   args[[name]] <- ""
[15:32:49.482]                 }
[15:32:49.482]                 NAMES <- toupper(removed)
[15:32:49.482]                 for (kk in seq_along(NAMES)) {
[15:32:49.482]                   name <- removed[[kk]]
[15:32:49.482]                   NAME <- NAMES[[kk]]
[15:32:49.482]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.482]                     next
[15:32:49.482]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.482]                 }
[15:32:49.482]                 if (length(args) > 0) 
[15:32:49.482]                   base::do.call(base::Sys.setenv, args = args)
[15:32:49.482]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:49.482]             }
[15:32:49.482]             else {
[15:32:49.482]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:49.482]             }
[15:32:49.482]             {
[15:32:49.482]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:49.482]                   0L) {
[15:32:49.482]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:49.482]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:49.482]                   base::options(opts)
[15:32:49.482]                 }
[15:32:49.482]                 {
[15:32:49.482]                   {
[15:32:49.482]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:49.482]                     NULL
[15:32:49.482]                   }
[15:32:49.482]                   options(future.plan = NULL)
[15:32:49.482]                   if (is.na(NA_character_)) 
[15:32:49.482]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.482]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:49.482]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:49.482]                     .init = FALSE)
[15:32:49.482]                 }
[15:32:49.482]             }
[15:32:49.482]         }
[15:32:49.482]     })
[15:32:49.482]     if (TRUE) {
[15:32:49.482]         base::sink(type = "output", split = FALSE)
[15:32:49.482]         if (TRUE) {
[15:32:49.482]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:49.482]         }
[15:32:49.482]         else {
[15:32:49.482]             ...future.result["stdout"] <- base::list(NULL)
[15:32:49.482]         }
[15:32:49.482]         base::close(...future.stdout)
[15:32:49.482]         ...future.stdout <- NULL
[15:32:49.482]     }
[15:32:49.482]     ...future.result$conditions <- ...future.conditions
[15:32:49.482]     ...future.result$finished <- base::Sys.time()
[15:32:49.482]     ...future.result
[15:32:49.482] }
[15:32:49.491] Exporting 5 global objects (45.86 KiB) to cluster node #1 ...
[15:32:49.492] Exporting '...future.FUN' (45.86 KiB) to cluster node #1 ...
[15:32:49.493] Exporting '...future.FUN' (45.86 KiB) to cluster node #1 ... DONE
[15:32:49.493] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:49.494] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:49.494] Exporting '...future.elements_ii' (288 bytes) to cluster node #1 ...
[15:32:49.495] Exporting '...future.elements_ii' (288 bytes) to cluster node #1 ... DONE
[15:32:49.495] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:49.496] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:49.496] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:49.497] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:49.497] Exporting 5 global objects (45.86 KiB) to cluster node #1 ... DONE
[15:32:49.498] MultisessionFuture started
[15:32:49.498] - Launch lazy future ... done
[15:32:49.498] run() for 'MultisessionFuture' ... done
[15:32:49.499] Created future:
[15:32:49.525] receiveMessageFromWorker() for ClusterFuture ...
[15:32:49.525] - Validating connection of MultisessionFuture
[15:32:49.525] - received message: FutureResult
[15:32:49.526] - Received FutureResult
[15:32:49.526] - Erased future from FutureRegistry
[15:32:49.526] result() for ClusterFuture ...
[15:32:49.526] - result already collected: FutureResult
[15:32:49.527] result() for ClusterFuture ... done
[15:32:49.527] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:49.499] MultisessionFuture:
[15:32:49.499] Label: 'future_sapply-1'
[15:32:49.499] Expression:
[15:32:49.499] {
[15:32:49.499]     do.call(function(...) {
[15:32:49.499]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.499]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.499]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.499]             on.exit(options(oopts), add = TRUE)
[15:32:49.499]         }
[15:32:49.499]         {
[15:32:49.499]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.499]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.499]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.499]             })
[15:32:49.499]         }
[15:32:49.499]     }, args = future.call.arguments)
[15:32:49.499] }
[15:32:49.499] Lazy evaluation: FALSE
[15:32:49.499] Asynchronous evaluation: TRUE
[15:32:49.499] Local evaluation: TRUE
[15:32:49.499] Environment: R_GlobalEnv
[15:32:49.499] Capture standard output: TRUE
[15:32:49.499] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:49.499] Globals: 5 objects totaling 46.14 KiB (function '...future.FUN' of 45.86 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 288 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:49.499] Packages: 1 packages ('stats')
[15:32:49.499] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:49.499] Resolved: TRUE
[15:32:49.499] Value: <not collected>
[15:32:49.499] Conditions captured: <none>
[15:32:49.499] Early signaling: FALSE
[15:32:49.499] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:49.499] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.528] Chunk #1 of 2 ... DONE
[15:32:49.528] Chunk #2 of 2 ...
[15:32:49.528]  - Finding globals in 'X' for chunk #2 ...
[15:32:49.528] getGlobalsAndPackages() ...
[15:32:49.529] Searching for globals...
[15:32:49.529] 
[15:32:49.529] Searching for globals ... DONE
[15:32:49.530] - globals: [0] <none>
[15:32:49.530] getGlobalsAndPackages() ... DONE
[15:32:49.530]    + additional globals found: [n=0] 
[15:32:49.531]    + additional namespaces needed: [n=0] 
[15:32:49.531]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:49.531]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:49.531]  - seeds: <none>
[15:32:49.532]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.532] getGlobalsAndPackages() ...
[15:32:49.532] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.532] Resolving globals: FALSE
[15:32:49.533] Tweak future expression to call with '...' arguments ...
[15:32:49.533] {
[15:32:49.533]     do.call(function(...) {
[15:32:49.533]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.533]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.533]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.533]             on.exit(options(oopts), add = TRUE)
[15:32:49.533]         }
[15:32:49.533]         {
[15:32:49.533]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.533]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.533]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.533]             })
[15:32:49.533]         }
[15:32:49.533]     }, args = future.call.arguments)
[15:32:49.533] }
[15:32:49.534] Tweak future expression to call with '...' arguments ... DONE
[15:32:49.535] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.535] - packages: [1] 'stats'
[15:32:49.535] getGlobalsAndPackages() ... DONE
[15:32:49.536] run() for 'Future' ...
[15:32:49.536] - state: 'created'
[15:32:49.536] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:49.553] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.553] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:49.554]   - Field: 'node'
[15:32:49.554]   - Field: 'label'
[15:32:49.554]   - Field: 'local'
[15:32:49.555]   - Field: 'owner'
[15:32:49.555]   - Field: 'envir'
[15:32:49.555]   - Field: 'workers'
[15:32:49.555]   - Field: 'packages'
[15:32:49.556]   - Field: 'gc'
[15:32:49.556]   - Field: 'conditions'
[15:32:49.556]   - Field: 'persistent'
[15:32:49.556]   - Field: 'expr'
[15:32:49.556]   - Field: 'uuid'
[15:32:49.557]   - Field: 'seed'
[15:32:49.557]   - Field: 'version'
[15:32:49.557]   - Field: 'result'
[15:32:49.557]   - Field: 'asynchronous'
[15:32:49.557]   - Field: 'calls'
[15:32:49.558]   - Field: 'globals'
[15:32:49.558]   - Field: 'stdout'
[15:32:49.558]   - Field: 'earlySignal'
[15:32:49.559]   - Field: 'lazy'
[15:32:49.559]   - Field: 'state'
[15:32:49.559] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:49.560] - Launch lazy future ...
[15:32:49.560] Packages needed by the future expression (n = 1): 'stats'
[15:32:49.561] Packages needed by future strategies (n = 0): <none>
[15:32:49.562] {
[15:32:49.562]     {
[15:32:49.562]         {
[15:32:49.562]             ...future.startTime <- base::Sys.time()
[15:32:49.562]             {
[15:32:49.562]                 {
[15:32:49.562]                   {
[15:32:49.562]                     {
[15:32:49.562]                       {
[15:32:49.562]                         base::local({
[15:32:49.562]                           has_future <- base::requireNamespace("future", 
[15:32:49.562]                             quietly = TRUE)
[15:32:49.562]                           if (has_future) {
[15:32:49.562]                             ns <- base::getNamespace("future")
[15:32:49.562]                             version <- ns[[".package"]][["version"]]
[15:32:49.562]                             if (is.null(version)) 
[15:32:49.562]                               version <- utils::packageVersion("future")
[15:32:49.562]                           }
[15:32:49.562]                           else {
[15:32:49.562]                             version <- NULL
[15:32:49.562]                           }
[15:32:49.562]                           if (!has_future || version < "1.8.0") {
[15:32:49.562]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:49.562]                               "", base::R.version$version.string), 
[15:32:49.562]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:49.562]                                 base::R.version$platform, 8 * 
[15:32:49.562]                                   base::.Machine$sizeof.pointer), 
[15:32:49.562]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:49.562]                                 "release", "version")], collapse = " "), 
[15:32:49.562]                               hostname = base::Sys.info()[["nodename"]])
[15:32:49.562]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:49.562]                               info)
[15:32:49.562]                             info <- base::paste(info, collapse = "; ")
[15:32:49.562]                             if (!has_future) {
[15:32:49.562]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:49.562]                                 info)
[15:32:49.562]                             }
[15:32:49.562]                             else {
[15:32:49.562]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:49.562]                                 info, version)
[15:32:49.562]                             }
[15:32:49.562]                             base::stop(msg)
[15:32:49.562]                           }
[15:32:49.562]                         })
[15:32:49.562]                       }
[15:32:49.562]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:49.562]                       base::options(mc.cores = 1L)
[15:32:49.562]                     }
[15:32:49.562]                     base::local({
[15:32:49.562]                       for (pkg in "stats") {
[15:32:49.562]                         base::loadNamespace(pkg)
[15:32:49.562]                         base::library(pkg, character.only = TRUE)
[15:32:49.562]                       }
[15:32:49.562]                     })
[15:32:49.562]                   }
[15:32:49.562]                   ...future.strategy.old <- future::plan("list")
[15:32:49.562]                   options(future.plan = NULL)
[15:32:49.562]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.562]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:49.562]                 }
[15:32:49.562]                 ...future.workdir <- getwd()
[15:32:49.562]             }
[15:32:49.562]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:49.562]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:49.562]         }
[15:32:49.562]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:49.562]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:49.562]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:49.562]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:49.562]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:49.562]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:49.562]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:49.562]             base::names(...future.oldOptions))
[15:32:49.562]     }
[15:32:49.562]     if (FALSE) {
[15:32:49.562]     }
[15:32:49.562]     else {
[15:32:49.562]         if (TRUE) {
[15:32:49.562]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:49.562]                 open = "w")
[15:32:49.562]         }
[15:32:49.562]         else {
[15:32:49.562]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:49.562]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:49.562]         }
[15:32:49.562]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:49.562]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:49.562]             base::sink(type = "output", split = FALSE)
[15:32:49.562]             base::close(...future.stdout)
[15:32:49.562]         }, add = TRUE)
[15:32:49.562]     }
[15:32:49.562]     ...future.frame <- base::sys.nframe()
[15:32:49.562]     ...future.conditions <- base::list()
[15:32:49.562]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:49.562]     if (FALSE) {
[15:32:49.562]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:49.562]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:49.562]     }
[15:32:49.562]     ...future.result <- base::tryCatch({
[15:32:49.562]         base::withCallingHandlers({
[15:32:49.562]             ...future.value <- base::withVisible(base::local({
[15:32:49.562]                 ...future.makeSendCondition <- base::local({
[15:32:49.562]                   sendCondition <- NULL
[15:32:49.562]                   function(frame = 1L) {
[15:32:49.562]                     if (is.function(sendCondition)) 
[15:32:49.562]                       return(sendCondition)
[15:32:49.562]                     ns <- getNamespace("parallel")
[15:32:49.562]                     if (exists("sendData", mode = "function", 
[15:32:49.562]                       envir = ns)) {
[15:32:49.562]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:49.562]                         envir = ns)
[15:32:49.562]                       envir <- sys.frame(frame)
[15:32:49.562]                       master <- NULL
[15:32:49.562]                       while (!identical(envir, .GlobalEnv) && 
[15:32:49.562]                         !identical(envir, emptyenv())) {
[15:32:49.562]                         if (exists("master", mode = "list", envir = envir, 
[15:32:49.562]                           inherits = FALSE)) {
[15:32:49.562]                           master <- get("master", mode = "list", 
[15:32:49.562]                             envir = envir, inherits = FALSE)
[15:32:49.562]                           if (inherits(master, c("SOCKnode", 
[15:32:49.562]                             "SOCK0node"))) {
[15:32:49.562]                             sendCondition <<- function(cond) {
[15:32:49.562]                               data <- list(type = "VALUE", value = cond, 
[15:32:49.562]                                 success = TRUE)
[15:32:49.562]                               parallel_sendData(master, data)
[15:32:49.562]                             }
[15:32:49.562]                             return(sendCondition)
[15:32:49.562]                           }
[15:32:49.562]                         }
[15:32:49.562]                         frame <- frame + 1L
[15:32:49.562]                         envir <- sys.frame(frame)
[15:32:49.562]                       }
[15:32:49.562]                     }
[15:32:49.562]                     sendCondition <<- function(cond) NULL
[15:32:49.562]                   }
[15:32:49.562]                 })
[15:32:49.562]                 withCallingHandlers({
[15:32:49.562]                   {
[15:32:49.562]                     do.call(function(...) {
[15:32:49.562]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.562]                       if (!identical(...future.globals.maxSize.org, 
[15:32:49.562]                         ...future.globals.maxSize)) {
[15:32:49.562]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.562]                         on.exit(options(oopts), add = TRUE)
[15:32:49.562]                       }
[15:32:49.562]                       {
[15:32:49.562]                         lapply(seq_along(...future.elements_ii), 
[15:32:49.562]                           FUN = function(jj) {
[15:32:49.562]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.562]                             ...future.FUN(...future.X_jj, ...)
[15:32:49.562]                           })
[15:32:49.562]                       }
[15:32:49.562]                     }, args = future.call.arguments)
[15:32:49.562]                   }
[15:32:49.562]                 }, immediateCondition = function(cond) {
[15:32:49.562]                   sendCondition <- ...future.makeSendCondition()
[15:32:49.562]                   sendCondition(cond)
[15:32:49.562]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.562]                   {
[15:32:49.562]                     inherits <- base::inherits
[15:32:49.562]                     invokeRestart <- base::invokeRestart
[15:32:49.562]                     is.null <- base::is.null
[15:32:49.562]                     muffled <- FALSE
[15:32:49.562]                     if (inherits(cond, "message")) {
[15:32:49.562]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:49.562]                       if (muffled) 
[15:32:49.562]                         invokeRestart("muffleMessage")
[15:32:49.562]                     }
[15:32:49.562]                     else if (inherits(cond, "warning")) {
[15:32:49.562]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:49.562]                       if (muffled) 
[15:32:49.562]                         invokeRestart("muffleWarning")
[15:32:49.562]                     }
[15:32:49.562]                     else if (inherits(cond, "condition")) {
[15:32:49.562]                       if (!is.null(pattern)) {
[15:32:49.562]                         computeRestarts <- base::computeRestarts
[15:32:49.562]                         grepl <- base::grepl
[15:32:49.562]                         restarts <- computeRestarts(cond)
[15:32:49.562]                         for (restart in restarts) {
[15:32:49.562]                           name <- restart$name
[15:32:49.562]                           if (is.null(name)) 
[15:32:49.562]                             next
[15:32:49.562]                           if (!grepl(pattern, name)) 
[15:32:49.562]                             next
[15:32:49.562]                           invokeRestart(restart)
[15:32:49.562]                           muffled <- TRUE
[15:32:49.562]                           break
[15:32:49.562]                         }
[15:32:49.562]                       }
[15:32:49.562]                     }
[15:32:49.562]                     invisible(muffled)
[15:32:49.562]                   }
[15:32:49.562]                   muffleCondition(cond)
[15:32:49.562]                 })
[15:32:49.562]             }))
[15:32:49.562]             future::FutureResult(value = ...future.value$value, 
[15:32:49.562]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.562]                   ...future.rng), globalenv = if (FALSE) 
[15:32:49.562]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:49.562]                     ...future.globalenv.names))
[15:32:49.562]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:49.562]         }, condition = base::local({
[15:32:49.562]             c <- base::c
[15:32:49.562]             inherits <- base::inherits
[15:32:49.562]             invokeRestart <- base::invokeRestart
[15:32:49.562]             length <- base::length
[15:32:49.562]             list <- base::list
[15:32:49.562]             seq.int <- base::seq.int
[15:32:49.562]             signalCondition <- base::signalCondition
[15:32:49.562]             sys.calls <- base::sys.calls
[15:32:49.562]             `[[` <- base::`[[`
[15:32:49.562]             `+` <- base::`+`
[15:32:49.562]             `<<-` <- base::`<<-`
[15:32:49.562]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:49.562]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:49.562]                   3L)]
[15:32:49.562]             }
[15:32:49.562]             function(cond) {
[15:32:49.562]                 is_error <- inherits(cond, "error")
[15:32:49.562]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:49.562]                   NULL)
[15:32:49.562]                 if (is_error) {
[15:32:49.562]                   sessionInformation <- function() {
[15:32:49.562]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:49.562]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:49.562]                       search = base::search(), system = base::Sys.info())
[15:32:49.562]                   }
[15:32:49.562]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.562]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:49.562]                     cond$call), session = sessionInformation(), 
[15:32:49.562]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:49.562]                   signalCondition(cond)
[15:32:49.562]                 }
[15:32:49.562]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:49.562]                 "immediateCondition"))) {
[15:32:49.562]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:49.562]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.562]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:49.562]                   if (TRUE && !signal) {
[15:32:49.562]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.562]                     {
[15:32:49.562]                       inherits <- base::inherits
[15:32:49.562]                       invokeRestart <- base::invokeRestart
[15:32:49.562]                       is.null <- base::is.null
[15:32:49.562]                       muffled <- FALSE
[15:32:49.562]                       if (inherits(cond, "message")) {
[15:32:49.562]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.562]                         if (muffled) 
[15:32:49.562]                           invokeRestart("muffleMessage")
[15:32:49.562]                       }
[15:32:49.562]                       else if (inherits(cond, "warning")) {
[15:32:49.562]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.562]                         if (muffled) 
[15:32:49.562]                           invokeRestart("muffleWarning")
[15:32:49.562]                       }
[15:32:49.562]                       else if (inherits(cond, "condition")) {
[15:32:49.562]                         if (!is.null(pattern)) {
[15:32:49.562]                           computeRestarts <- base::computeRestarts
[15:32:49.562]                           grepl <- base::grepl
[15:32:49.562]                           restarts <- computeRestarts(cond)
[15:32:49.562]                           for (restart in restarts) {
[15:32:49.562]                             name <- restart$name
[15:32:49.562]                             if (is.null(name)) 
[15:32:49.562]                               next
[15:32:49.562]                             if (!grepl(pattern, name)) 
[15:32:49.562]                               next
[15:32:49.562]                             invokeRestart(restart)
[15:32:49.562]                             muffled <- TRUE
[15:32:49.562]                             break
[15:32:49.562]                           }
[15:32:49.562]                         }
[15:32:49.562]                       }
[15:32:49.562]                       invisible(muffled)
[15:32:49.562]                     }
[15:32:49.562]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.562]                   }
[15:32:49.562]                 }
[15:32:49.562]                 else {
[15:32:49.562]                   if (TRUE) {
[15:32:49.562]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.562]                     {
[15:32:49.562]                       inherits <- base::inherits
[15:32:49.562]                       invokeRestart <- base::invokeRestart
[15:32:49.562]                       is.null <- base::is.null
[15:32:49.562]                       muffled <- FALSE
[15:32:49.562]                       if (inherits(cond, "message")) {
[15:32:49.562]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.562]                         if (muffled) 
[15:32:49.562]                           invokeRestart("muffleMessage")
[15:32:49.562]                       }
[15:32:49.562]                       else if (inherits(cond, "warning")) {
[15:32:49.562]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.562]                         if (muffled) 
[15:32:49.562]                           invokeRestart("muffleWarning")
[15:32:49.562]                       }
[15:32:49.562]                       else if (inherits(cond, "condition")) {
[15:32:49.562]                         if (!is.null(pattern)) {
[15:32:49.562]                           computeRestarts <- base::computeRestarts
[15:32:49.562]                           grepl <- base::grepl
[15:32:49.562]                           restarts <- computeRestarts(cond)
[15:32:49.562]                           for (restart in restarts) {
[15:32:49.562]                             name <- restart$name
[15:32:49.562]                             if (is.null(name)) 
[15:32:49.562]                               next
[15:32:49.562]                             if (!grepl(pattern, name)) 
[15:32:49.562]                               next
[15:32:49.562]                             invokeRestart(restart)
[15:32:49.562]                             muffled <- TRUE
[15:32:49.562]                             break
[15:32:49.562]                           }
[15:32:49.562]                         }
[15:32:49.562]                       }
[15:32:49.562]                       invisible(muffled)
[15:32:49.562]                     }
[15:32:49.562]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.562]                   }
[15:32:49.562]                 }
[15:32:49.562]             }
[15:32:49.562]         }))
[15:32:49.562]     }, error = function(ex) {
[15:32:49.562]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:49.562]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.562]                 ...future.rng), started = ...future.startTime, 
[15:32:49.562]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:49.562]             version = "1.8"), class = "FutureResult")
[15:32:49.562]     }, finally = {
[15:32:49.562]         if (!identical(...future.workdir, getwd())) 
[15:32:49.562]             setwd(...future.workdir)
[15:32:49.562]         {
[15:32:49.562]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:49.562]                 ...future.oldOptions$nwarnings <- NULL
[15:32:49.562]             }
[15:32:49.562]             base::options(...future.oldOptions)
[15:32:49.562]             if (.Platform$OS.type == "windows") {
[15:32:49.562]                 old_names <- names(...future.oldEnvVars)
[15:32:49.562]                 envs <- base::Sys.getenv()
[15:32:49.562]                 names <- names(envs)
[15:32:49.562]                 common <- intersect(names, old_names)
[15:32:49.562]                 added <- setdiff(names, old_names)
[15:32:49.562]                 removed <- setdiff(old_names, names)
[15:32:49.562]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:49.562]                   envs[common]]
[15:32:49.562]                 NAMES <- toupper(changed)
[15:32:49.562]                 args <- list()
[15:32:49.562]                 for (kk in seq_along(NAMES)) {
[15:32:49.562]                   name <- changed[[kk]]
[15:32:49.562]                   NAME <- NAMES[[kk]]
[15:32:49.562]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.562]                     next
[15:32:49.562]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.562]                 }
[15:32:49.562]                 NAMES <- toupper(added)
[15:32:49.562]                 for (kk in seq_along(NAMES)) {
[15:32:49.562]                   name <- added[[kk]]
[15:32:49.562]                   NAME <- NAMES[[kk]]
[15:32:49.562]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.562]                     next
[15:32:49.562]                   args[[name]] <- ""
[15:32:49.562]                 }
[15:32:49.562]                 NAMES <- toupper(removed)
[15:32:49.562]                 for (kk in seq_along(NAMES)) {
[15:32:49.562]                   name <- removed[[kk]]
[15:32:49.562]                   NAME <- NAMES[[kk]]
[15:32:49.562]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.562]                     next
[15:32:49.562]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.562]                 }
[15:32:49.562]                 if (length(args) > 0) 
[15:32:49.562]                   base::do.call(base::Sys.setenv, args = args)
[15:32:49.562]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:49.562]             }
[15:32:49.562]             else {
[15:32:49.562]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:49.562]             }
[15:32:49.562]             {
[15:32:49.562]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:49.562]                   0L) {
[15:32:49.562]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:49.562]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:49.562]                   base::options(opts)
[15:32:49.562]                 }
[15:32:49.562]                 {
[15:32:49.562]                   {
[15:32:49.562]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:49.562]                     NULL
[15:32:49.562]                   }
[15:32:49.562]                   options(future.plan = NULL)
[15:32:49.562]                   if (is.na(NA_character_)) 
[15:32:49.562]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.562]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:49.562]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:49.562]                     .init = FALSE)
[15:32:49.562]                 }
[15:32:49.562]             }
[15:32:49.562]         }
[15:32:49.562]     })
[15:32:49.562]     if (TRUE) {
[15:32:49.562]         base::sink(type = "output", split = FALSE)
[15:32:49.562]         if (TRUE) {
[15:32:49.562]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:49.562]         }
[15:32:49.562]         else {
[15:32:49.562]             ...future.result["stdout"] <- base::list(NULL)
[15:32:49.562]         }
[15:32:49.562]         base::close(...future.stdout)
[15:32:49.562]         ...future.stdout <- NULL
[15:32:49.562]     }
[15:32:49.562]     ...future.result$conditions <- ...future.conditions
[15:32:49.562]     ...future.result$finished <- base::Sys.time()
[15:32:49.562]     ...future.result
[15:32:49.562] }
[15:32:49.570] Exporting 5 global objects (45.86 KiB) to cluster node #1 ...
[15:32:49.570] Exporting '...future.FUN' (45.86 KiB) to cluster node #1 ...
[15:32:49.570] Exporting '...future.FUN' (45.86 KiB) to cluster node #1 ... DONE
[15:32:49.571] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:49.571] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:49.572] Exporting '...future.elements_ii' (256 bytes) to cluster node #1 ...
[15:32:49.572] Exporting '...future.elements_ii' (256 bytes) to cluster node #1 ... DONE
[15:32:49.572] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:49.573] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:49.573] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:49.574] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:49.574] Exporting 5 global objects (45.86 KiB) to cluster node #1 ... DONE
[15:32:49.575] MultisessionFuture started
[15:32:49.575] - Launch lazy future ... done
[15:32:49.575] run() for 'MultisessionFuture' ... done
[15:32:49.576] Created future:
[15:32:49.594] receiveMessageFromWorker() for ClusterFuture ...
[15:32:49.595] - Validating connection of MultisessionFuture
[15:32:49.595] - received message: FutureResult
[15:32:49.595] - Received FutureResult
[15:32:49.596] - Erased future from FutureRegistry
[15:32:49.596] result() for ClusterFuture ...
[15:32:49.596] - result already collected: FutureResult
[15:32:49.597] result() for ClusterFuture ... done
[15:32:49.597] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:49.576] MultisessionFuture:
[15:32:49.576] Label: 'future_sapply-2'
[15:32:49.576] Expression:
[15:32:49.576] {
[15:32:49.576]     do.call(function(...) {
[15:32:49.576]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.576]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.576]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.576]             on.exit(options(oopts), add = TRUE)
[15:32:49.576]         }
[15:32:49.576]         {
[15:32:49.576]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.576]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.576]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.576]             })
[15:32:49.576]         }
[15:32:49.576]     }, args = future.call.arguments)
[15:32:49.576] }
[15:32:49.576] Lazy evaluation: FALSE
[15:32:49.576] Asynchronous evaluation: TRUE
[15:32:49.576] Local evaluation: TRUE
[15:32:49.576] Environment: R_GlobalEnv
[15:32:49.576] Capture standard output: TRUE
[15:32:49.576] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:49.576] Globals: 5 objects totaling 46.11 KiB (function '...future.FUN' of 45.86 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 256 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:49.576] Packages: 1 packages ('stats')
[15:32:49.576] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:49.576] Resolved: TRUE
[15:32:49.576] Value: <not collected>
[15:32:49.576] Conditions captured: <none>
[15:32:49.576] Early signaling: FALSE
[15:32:49.576] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:49.576] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.598] Chunk #2 of 2 ... DONE
[15:32:49.598] Launching 2 futures (chunks) ... DONE
[15:32:49.598] Resolving 2 futures (chunks) ...
[15:32:49.598] resolve() on list ...
[15:32:49.599]  recursive: 0
[15:32:49.599]  length: 2
[15:32:49.599] 
[15:32:49.599] Future #1
[15:32:49.600] result() for ClusterFuture ...
[15:32:49.600] - result already collected: FutureResult
[15:32:49.600] result() for ClusterFuture ... done
[15:32:49.601] result() for ClusterFuture ...
[15:32:49.601] - result already collected: FutureResult
[15:32:49.601] result() for ClusterFuture ... done
[15:32:49.601] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:49.602] - nx: 2
[15:32:49.602] - relay: TRUE
[15:32:49.602] - stdout: TRUE
[15:32:49.602] - signal: TRUE
[15:32:49.603] - resignal: FALSE
[15:32:49.603] - force: TRUE
[15:32:49.603] - relayed: [n=2] FALSE, FALSE
[15:32:49.603] - queued futures: [n=2] FALSE, FALSE
[15:32:49.604]  - until=1
[15:32:49.604]  - relaying element #1
[15:32:49.608] result() for ClusterFuture ...
[15:32:49.608] - result already collected: FutureResult
[15:32:49.608] result() for ClusterFuture ... done
[15:32:49.609] result() for ClusterFuture ...
[15:32:49.609] - result already collected: FutureResult
[15:32:49.609] result() for ClusterFuture ... done
[15:32:49.610] result() for ClusterFuture ...
[15:32:49.610] - result already collected: FutureResult
[15:32:49.610] result() for ClusterFuture ... done
[15:32:49.610] result() for ClusterFuture ...
[15:32:49.611] - result already collected: FutureResult
[15:32:49.611] result() for ClusterFuture ... done
[15:32:49.611] - relayed: [n=2] TRUE, FALSE
[15:32:49.611] - queued futures: [n=2] TRUE, FALSE
[15:32:49.612] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:49.612]  length: 1 (resolved future 1)
[15:32:49.612] Future #2
[15:32:49.612] result() for ClusterFuture ...
[15:32:49.613] - result already collected: FutureResult
[15:32:49.613] result() for ClusterFuture ... done
[15:32:49.613] result() for ClusterFuture ...
[15:32:49.613] - result already collected: FutureResult
[15:32:49.614] result() for ClusterFuture ... done
[15:32:49.614] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:49.614] - nx: 2
[15:32:49.615] - relay: TRUE
[15:32:49.615] - stdout: TRUE
[15:32:49.615] - signal: TRUE
[15:32:49.615] - resignal: FALSE
[15:32:49.616] - force: TRUE
[15:32:49.616] - relayed: [n=2] TRUE, FALSE
[15:32:49.616] - queued futures: [n=2] TRUE, FALSE
[15:32:49.616]  - until=2
[15:32:49.617]  - relaying element #2
[15:32:49.617] result() for ClusterFuture ...
[15:32:49.617] - result already collected: FutureResult
[15:32:49.617] result() for ClusterFuture ... done
[15:32:49.618] result() for ClusterFuture ...
[15:32:49.618] - result already collected: FutureResult
[15:32:49.618] result() for ClusterFuture ... done
[15:32:49.618] result() for ClusterFuture ...
[15:32:49.619] - result already collected: FutureResult
[15:32:49.619] result() for ClusterFuture ... done
[15:32:49.619] result() for ClusterFuture ...
[15:32:49.619] - result already collected: FutureResult
[15:32:49.620] result() for ClusterFuture ... done
[15:32:49.620] - relayed: [n=2] TRUE, TRUE
[15:32:49.620] - queued futures: [n=2] TRUE, TRUE
[15:32:49.620] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:49.621]  length: 0 (resolved future 2)
[15:32:49.621] Relaying remaining futures
[15:32:49.621] signalConditionsASAP(NULL, pos=0) ...
[15:32:49.621] - nx: 2
[15:32:49.621] - relay: TRUE
[15:32:49.622] - stdout: TRUE
[15:32:49.622] - signal: TRUE
[15:32:49.622] - resignal: FALSE
[15:32:49.622] - force: TRUE
[15:32:49.623] - relayed: [n=2] TRUE, TRUE
[15:32:49.623] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:49.623] - relayed: [n=2] TRUE, TRUE
[15:32:49.623] - queued futures: [n=2] TRUE, TRUE
[15:32:49.624] signalConditionsASAP(NULL, pos=0) ... done
[15:32:49.624] resolve() on list ... DONE
[15:32:49.624] result() for ClusterFuture ...
[15:32:49.624] - result already collected: FutureResult
[15:32:49.625] result() for ClusterFuture ... done
[15:32:49.625] result() for ClusterFuture ...
[15:32:49.625] - result already collected: FutureResult
[15:32:49.625] result() for ClusterFuture ... done
[15:32:49.626] result() for ClusterFuture ...
[15:32:49.626] - result already collected: FutureResult
[15:32:49.626] result() for ClusterFuture ... done
[15:32:49.626] result() for ClusterFuture ...
[15:32:49.627] - result already collected: FutureResult
[15:32:49.627] result() for ClusterFuture ... done
[15:32:49.627]  - Number of value chunks collected: 2
[15:32:49.627] Resolving 2 futures (chunks) ... DONE
[15:32:49.628] Reducing values from 2 chunks ...
[15:32:49.628]  - Number of values collected after concatenation: 7
[15:32:49.628]  - Number of values expected: 7
[15:32:49.628] Reducing values from 2 chunks ... DONE
[15:32:49.629] future_lapply() ... DONE
[15:32:49.629] future_lapply() ...
[15:32:49.637] Number of chunks: 2
[15:32:49.637] getGlobalsAndPackagesXApply() ...
[15:32:49.638]  - future.globals: TRUE
[15:32:49.638] getGlobalsAndPackages() ...
[15:32:49.638] Searching for globals...
[15:32:49.655] - globals found: [31] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'is.na', 'any', '[', '!', 'return', 'rep.int', 'sort', '/', 'floor', '(', '+', 'c', '-', '*', 'ceiling'
[15:32:49.655] Searching for globals ... DONE
[15:32:49.655] Resolving globals: FALSE
[15:32:49.658] The total size of the 7 globals is 137.93 KiB (141240 bytes)
[15:32:49.658] The total size of the 7 globals exported for future expression ('FUN()') is 137.93 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'x_FUN' (45.86 KiB of class 'function'), 'stop_if_not' (44.12 KiB of class 'function') and 'stopf' (26.43 KiB of class 'function')
[15:32:49.659] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:49.659] - packages: [2] 'stats', 'future.apply'
[15:32:49.659] getGlobalsAndPackages() ... DONE
[15:32:49.660]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:49.660]  - needed namespaces: [n=2] 'stats', 'future.apply'
[15:32:49.660] Finding globals ... DONE
[15:32:49.661]  - use_args: TRUE
[15:32:49.661]  - Getting '...' globals ...
[15:32:49.662] resolve() on list ...
[15:32:49.662]  recursive: 0
[15:32:49.662]  length: 1
[15:32:49.662]  elements: '...'
[15:32:49.663]  length: 0 (resolved future 1)
[15:32:49.663] resolve() on list ... DONE
[15:32:49.663]    - '...' content: [n=0] 
[15:32:49.663] List of 1
[15:32:49.663]  $ ...: list()
[15:32:49.663]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:49.663]  - attr(*, "where")=List of 1
[15:32:49.663]   ..$ ...:<environment: 0x0000022d3e3456f8> 
[15:32:49.663]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:49.663]  - attr(*, "resolved")= logi TRUE
[15:32:49.663]  - attr(*, "total_size")= num NA
[15:32:49.668]  - Getting '...' globals ... DONE
[15:32:49.669] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:49.669] List of 8
[15:32:49.669]  $ ...future.FUN:function (x, ...)  
[15:32:49.669]  $ x_FUN        :function (x, na.rm = TRUE)  
[15:32:49.669]  $ times        : int 5
[15:32:49.669]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:49.669]  $ stop_if_not  :function (...)  
[15:32:49.669]  $ dim          : NULL
[15:32:49.669]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:49.669]  $ ...          : list()
[15:32:49.669]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:49.669]  - attr(*, "where")=List of 8
[15:32:49.669]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:49.669]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:49.669]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:49.669]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:49.669]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:49.669]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:49.669]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:49.669]   ..$ ...          :<environment: 0x0000022d3e3456f8> 
[15:32:49.669]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:49.669]  - attr(*, "resolved")= logi FALSE
[15:32:49.669]  - attr(*, "total_size")= num 141240
[15:32:49.679] Packages to be attached in all futures: [n=2] 'stats', 'future.apply'
[15:32:49.680] getGlobalsAndPackagesXApply() ... DONE
[15:32:49.680] Number of futures (= number of chunks): 2
[15:32:49.680] Launching 2 futures (chunks) ...
[15:32:49.681] Chunk #1 of 2 ...
[15:32:49.681]  - Finding globals in 'X' for chunk #1 ...
[15:32:49.681] getGlobalsAndPackages() ...
[15:32:49.682] Searching for globals...
[15:32:49.682] 
[15:32:49.682] Searching for globals ... DONE
[15:32:49.683] - globals: [0] <none>
[15:32:49.683] getGlobalsAndPackages() ... DONE
[15:32:49.683]    + additional globals found: [n=0] 
[15:32:49.683]    + additional namespaces needed: [n=0] 
[15:32:49.684]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:49.684]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:49.684]  - seeds: <none>
[15:32:49.684]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.685] getGlobalsAndPackages() ...
[15:32:49.685] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.685] Resolving globals: FALSE
[15:32:49.686] Tweak future expression to call with '...' arguments ...
[15:32:49.686] {
[15:32:49.686]     do.call(function(...) {
[15:32:49.686]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.686]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.686]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.686]             on.exit(options(oopts), add = TRUE)
[15:32:49.686]         }
[15:32:49.686]         {
[15:32:49.686]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.686]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.686]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.686]             })
[15:32:49.686]         }
[15:32:49.686]     }, args = future.call.arguments)
[15:32:49.686] }
[15:32:49.687] Tweak future expression to call with '...' arguments ... DONE
[15:32:49.688] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.688] - packages: [2] 'stats', 'future.apply'
[15:32:49.688] getGlobalsAndPackages() ... DONE
[15:32:49.689] run() for 'Future' ...
[15:32:49.689] - state: 'created'
[15:32:49.690] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:49.707] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.708] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:49.708]   - Field: 'node'
[15:32:49.708]   - Field: 'label'
[15:32:49.709]   - Field: 'local'
[15:32:49.709]   - Field: 'owner'
[15:32:49.709]   - Field: 'envir'
[15:32:49.709]   - Field: 'workers'
[15:32:49.710]   - Field: 'packages'
[15:32:49.710]   - Field: 'gc'
[15:32:49.710]   - Field: 'conditions'
[15:32:49.711]   - Field: 'persistent'
[15:32:49.711]   - Field: 'expr'
[15:32:49.711]   - Field: 'uuid'
[15:32:49.712]   - Field: 'seed'
[15:32:49.712]   - Field: 'version'
[15:32:49.712]   - Field: 'result'
[15:32:49.712]   - Field: 'asynchronous'
[15:32:49.713]   - Field: 'calls'
[15:32:49.713]   - Field: 'globals'
[15:32:49.713]   - Field: 'stdout'
[15:32:49.713]   - Field: 'earlySignal'
[15:32:49.714]   - Field: 'lazy'
[15:32:49.714]   - Field: 'state'
[15:32:49.714] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:49.714] - Launch lazy future ...
[15:32:49.715] Packages needed by the future expression (n = 2): 'stats', 'future.apply'
[15:32:49.715] Packages needed by future strategies (n = 0): <none>
[15:32:49.716] {
[15:32:49.716]     {
[15:32:49.716]         {
[15:32:49.716]             ...future.startTime <- base::Sys.time()
[15:32:49.716]             {
[15:32:49.716]                 {
[15:32:49.716]                   {
[15:32:49.716]                     {
[15:32:49.716]                       {
[15:32:49.716]                         base::local({
[15:32:49.716]                           has_future <- base::requireNamespace("future", 
[15:32:49.716]                             quietly = TRUE)
[15:32:49.716]                           if (has_future) {
[15:32:49.716]                             ns <- base::getNamespace("future")
[15:32:49.716]                             version <- ns[[".package"]][["version"]]
[15:32:49.716]                             if (is.null(version)) 
[15:32:49.716]                               version <- utils::packageVersion("future")
[15:32:49.716]                           }
[15:32:49.716]                           else {
[15:32:49.716]                             version <- NULL
[15:32:49.716]                           }
[15:32:49.716]                           if (!has_future || version < "1.8.0") {
[15:32:49.716]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:49.716]                               "", base::R.version$version.string), 
[15:32:49.716]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:49.716]                                 base::R.version$platform, 8 * 
[15:32:49.716]                                   base::.Machine$sizeof.pointer), 
[15:32:49.716]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:49.716]                                 "release", "version")], collapse = " "), 
[15:32:49.716]                               hostname = base::Sys.info()[["nodename"]])
[15:32:49.716]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:49.716]                               info)
[15:32:49.716]                             info <- base::paste(info, collapse = "; ")
[15:32:49.716]                             if (!has_future) {
[15:32:49.716]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:49.716]                                 info)
[15:32:49.716]                             }
[15:32:49.716]                             else {
[15:32:49.716]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:49.716]                                 info, version)
[15:32:49.716]                             }
[15:32:49.716]                             base::stop(msg)
[15:32:49.716]                           }
[15:32:49.716]                         })
[15:32:49.716]                       }
[15:32:49.716]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:49.716]                       base::options(mc.cores = 1L)
[15:32:49.716]                     }
[15:32:49.716]                     base::local({
[15:32:49.716]                       for (pkg in c("stats", "future.apply")) {
[15:32:49.716]                         base::loadNamespace(pkg)
[15:32:49.716]                         base::library(pkg, character.only = TRUE)
[15:32:49.716]                       }
[15:32:49.716]                     })
[15:32:49.716]                   }
[15:32:49.716]                   ...future.strategy.old <- future::plan("list")
[15:32:49.716]                   options(future.plan = NULL)
[15:32:49.716]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.716]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:49.716]                 }
[15:32:49.716]                 ...future.workdir <- getwd()
[15:32:49.716]             }
[15:32:49.716]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:49.716]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:49.716]         }
[15:32:49.716]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:49.716]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:49.716]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:49.716]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:49.716]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:49.716]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:49.716]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:49.716]             base::names(...future.oldOptions))
[15:32:49.716]     }
[15:32:49.716]     if (FALSE) {
[15:32:49.716]     }
[15:32:49.716]     else {
[15:32:49.716]         if (TRUE) {
[15:32:49.716]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:49.716]                 open = "w")
[15:32:49.716]         }
[15:32:49.716]         else {
[15:32:49.716]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:49.716]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:49.716]         }
[15:32:49.716]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:49.716]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:49.716]             base::sink(type = "output", split = FALSE)
[15:32:49.716]             base::close(...future.stdout)
[15:32:49.716]         }, add = TRUE)
[15:32:49.716]     }
[15:32:49.716]     ...future.frame <- base::sys.nframe()
[15:32:49.716]     ...future.conditions <- base::list()
[15:32:49.716]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:49.716]     if (FALSE) {
[15:32:49.716]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:49.716]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:49.716]     }
[15:32:49.716]     ...future.result <- base::tryCatch({
[15:32:49.716]         base::withCallingHandlers({
[15:32:49.716]             ...future.value <- base::withVisible(base::local({
[15:32:49.716]                 ...future.makeSendCondition <- base::local({
[15:32:49.716]                   sendCondition <- NULL
[15:32:49.716]                   function(frame = 1L) {
[15:32:49.716]                     if (is.function(sendCondition)) 
[15:32:49.716]                       return(sendCondition)
[15:32:49.716]                     ns <- getNamespace("parallel")
[15:32:49.716]                     if (exists("sendData", mode = "function", 
[15:32:49.716]                       envir = ns)) {
[15:32:49.716]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:49.716]                         envir = ns)
[15:32:49.716]                       envir <- sys.frame(frame)
[15:32:49.716]                       master <- NULL
[15:32:49.716]                       while (!identical(envir, .GlobalEnv) && 
[15:32:49.716]                         !identical(envir, emptyenv())) {
[15:32:49.716]                         if (exists("master", mode = "list", envir = envir, 
[15:32:49.716]                           inherits = FALSE)) {
[15:32:49.716]                           master <- get("master", mode = "list", 
[15:32:49.716]                             envir = envir, inherits = FALSE)
[15:32:49.716]                           if (inherits(master, c("SOCKnode", 
[15:32:49.716]                             "SOCK0node"))) {
[15:32:49.716]                             sendCondition <<- function(cond) {
[15:32:49.716]                               data <- list(type = "VALUE", value = cond, 
[15:32:49.716]                                 success = TRUE)
[15:32:49.716]                               parallel_sendData(master, data)
[15:32:49.716]                             }
[15:32:49.716]                             return(sendCondition)
[15:32:49.716]                           }
[15:32:49.716]                         }
[15:32:49.716]                         frame <- frame + 1L
[15:32:49.716]                         envir <- sys.frame(frame)
[15:32:49.716]                       }
[15:32:49.716]                     }
[15:32:49.716]                     sendCondition <<- function(cond) NULL
[15:32:49.716]                   }
[15:32:49.716]                 })
[15:32:49.716]                 withCallingHandlers({
[15:32:49.716]                   {
[15:32:49.716]                     do.call(function(...) {
[15:32:49.716]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.716]                       if (!identical(...future.globals.maxSize.org, 
[15:32:49.716]                         ...future.globals.maxSize)) {
[15:32:49.716]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.716]                         on.exit(options(oopts), add = TRUE)
[15:32:49.716]                       }
[15:32:49.716]                       {
[15:32:49.716]                         lapply(seq_along(...future.elements_ii), 
[15:32:49.716]                           FUN = function(jj) {
[15:32:49.716]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.716]                             ...future.FUN(...future.X_jj, ...)
[15:32:49.716]                           })
[15:32:49.716]                       }
[15:32:49.716]                     }, args = future.call.arguments)
[15:32:49.716]                   }
[15:32:49.716]                 }, immediateCondition = function(cond) {
[15:32:49.716]                   sendCondition <- ...future.makeSendCondition()
[15:32:49.716]                   sendCondition(cond)
[15:32:49.716]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.716]                   {
[15:32:49.716]                     inherits <- base::inherits
[15:32:49.716]                     invokeRestart <- base::invokeRestart
[15:32:49.716]                     is.null <- base::is.null
[15:32:49.716]                     muffled <- FALSE
[15:32:49.716]                     if (inherits(cond, "message")) {
[15:32:49.716]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:49.716]                       if (muffled) 
[15:32:49.716]                         invokeRestart("muffleMessage")
[15:32:49.716]                     }
[15:32:49.716]                     else if (inherits(cond, "warning")) {
[15:32:49.716]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:49.716]                       if (muffled) 
[15:32:49.716]                         invokeRestart("muffleWarning")
[15:32:49.716]                     }
[15:32:49.716]                     else if (inherits(cond, "condition")) {
[15:32:49.716]                       if (!is.null(pattern)) {
[15:32:49.716]                         computeRestarts <- base::computeRestarts
[15:32:49.716]                         grepl <- base::grepl
[15:32:49.716]                         restarts <- computeRestarts(cond)
[15:32:49.716]                         for (restart in restarts) {
[15:32:49.716]                           name <- restart$name
[15:32:49.716]                           if (is.null(name)) 
[15:32:49.716]                             next
[15:32:49.716]                           if (!grepl(pattern, name)) 
[15:32:49.716]                             next
[15:32:49.716]                           invokeRestart(restart)
[15:32:49.716]                           muffled <- TRUE
[15:32:49.716]                           break
[15:32:49.716]                         }
[15:32:49.716]                       }
[15:32:49.716]                     }
[15:32:49.716]                     invisible(muffled)
[15:32:49.716]                   }
[15:32:49.716]                   muffleCondition(cond)
[15:32:49.716]                 })
[15:32:49.716]             }))
[15:32:49.716]             future::FutureResult(value = ...future.value$value, 
[15:32:49.716]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.716]                   ...future.rng), globalenv = if (FALSE) 
[15:32:49.716]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:49.716]                     ...future.globalenv.names))
[15:32:49.716]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:49.716]         }, condition = base::local({
[15:32:49.716]             c <- base::c
[15:32:49.716]             inherits <- base::inherits
[15:32:49.716]             invokeRestart <- base::invokeRestart
[15:32:49.716]             length <- base::length
[15:32:49.716]             list <- base::list
[15:32:49.716]             seq.int <- base::seq.int
[15:32:49.716]             signalCondition <- base::signalCondition
[15:32:49.716]             sys.calls <- base::sys.calls
[15:32:49.716]             `[[` <- base::`[[`
[15:32:49.716]             `+` <- base::`+`
[15:32:49.716]             `<<-` <- base::`<<-`
[15:32:49.716]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:49.716]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:49.716]                   3L)]
[15:32:49.716]             }
[15:32:49.716]             function(cond) {
[15:32:49.716]                 is_error <- inherits(cond, "error")
[15:32:49.716]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:49.716]                   NULL)
[15:32:49.716]                 if (is_error) {
[15:32:49.716]                   sessionInformation <- function() {
[15:32:49.716]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:49.716]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:49.716]                       search = base::search(), system = base::Sys.info())
[15:32:49.716]                   }
[15:32:49.716]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.716]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:49.716]                     cond$call), session = sessionInformation(), 
[15:32:49.716]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:49.716]                   signalCondition(cond)
[15:32:49.716]                 }
[15:32:49.716]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:49.716]                 "immediateCondition"))) {
[15:32:49.716]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:49.716]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.716]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:49.716]                   if (TRUE && !signal) {
[15:32:49.716]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.716]                     {
[15:32:49.716]                       inherits <- base::inherits
[15:32:49.716]                       invokeRestart <- base::invokeRestart
[15:32:49.716]                       is.null <- base::is.null
[15:32:49.716]                       muffled <- FALSE
[15:32:49.716]                       if (inherits(cond, "message")) {
[15:32:49.716]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.716]                         if (muffled) 
[15:32:49.716]                           invokeRestart("muffleMessage")
[15:32:49.716]                       }
[15:32:49.716]                       else if (inherits(cond, "warning")) {
[15:32:49.716]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.716]                         if (muffled) 
[15:32:49.716]                           invokeRestart("muffleWarning")
[15:32:49.716]                       }
[15:32:49.716]                       else if (inherits(cond, "condition")) {
[15:32:49.716]                         if (!is.null(pattern)) {
[15:32:49.716]                           computeRestarts <- base::computeRestarts
[15:32:49.716]                           grepl <- base::grepl
[15:32:49.716]                           restarts <- computeRestarts(cond)
[15:32:49.716]                           for (restart in restarts) {
[15:32:49.716]                             name <- restart$name
[15:32:49.716]                             if (is.null(name)) 
[15:32:49.716]                               next
[15:32:49.716]                             if (!grepl(pattern, name)) 
[15:32:49.716]                               next
[15:32:49.716]                             invokeRestart(restart)
[15:32:49.716]                             muffled <- TRUE
[15:32:49.716]                             break
[15:32:49.716]                           }
[15:32:49.716]                         }
[15:32:49.716]                       }
[15:32:49.716]                       invisible(muffled)
[15:32:49.716]                     }
[15:32:49.716]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.716]                   }
[15:32:49.716]                 }
[15:32:49.716]                 else {
[15:32:49.716]                   if (TRUE) {
[15:32:49.716]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.716]                     {
[15:32:49.716]                       inherits <- base::inherits
[15:32:49.716]                       invokeRestart <- base::invokeRestart
[15:32:49.716]                       is.null <- base::is.null
[15:32:49.716]                       muffled <- FALSE
[15:32:49.716]                       if (inherits(cond, "message")) {
[15:32:49.716]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.716]                         if (muffled) 
[15:32:49.716]                           invokeRestart("muffleMessage")
[15:32:49.716]                       }
[15:32:49.716]                       else if (inherits(cond, "warning")) {
[15:32:49.716]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.716]                         if (muffled) 
[15:32:49.716]                           invokeRestart("muffleWarning")
[15:32:49.716]                       }
[15:32:49.716]                       else if (inherits(cond, "condition")) {
[15:32:49.716]                         if (!is.null(pattern)) {
[15:32:49.716]                           computeRestarts <- base::computeRestarts
[15:32:49.716]                           grepl <- base::grepl
[15:32:49.716]                           restarts <- computeRestarts(cond)
[15:32:49.716]                           for (restart in restarts) {
[15:32:49.716]                             name <- restart$name
[15:32:49.716]                             if (is.null(name)) 
[15:32:49.716]                               next
[15:32:49.716]                             if (!grepl(pattern, name)) 
[15:32:49.716]                               next
[15:32:49.716]                             invokeRestart(restart)
[15:32:49.716]                             muffled <- TRUE
[15:32:49.716]                             break
[15:32:49.716]                           }
[15:32:49.716]                         }
[15:32:49.716]                       }
[15:32:49.716]                       invisible(muffled)
[15:32:49.716]                     }
[15:32:49.716]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.716]                   }
[15:32:49.716]                 }
[15:32:49.716]             }
[15:32:49.716]         }))
[15:32:49.716]     }, error = function(ex) {
[15:32:49.716]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:49.716]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.716]                 ...future.rng), started = ...future.startTime, 
[15:32:49.716]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:49.716]             version = "1.8"), class = "FutureResult")
[15:32:49.716]     }, finally = {
[15:32:49.716]         if (!identical(...future.workdir, getwd())) 
[15:32:49.716]             setwd(...future.workdir)
[15:32:49.716]         {
[15:32:49.716]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:49.716]                 ...future.oldOptions$nwarnings <- NULL
[15:32:49.716]             }
[15:32:49.716]             base::options(...future.oldOptions)
[15:32:49.716]             if (.Platform$OS.type == "windows") {
[15:32:49.716]                 old_names <- names(...future.oldEnvVars)
[15:32:49.716]                 envs <- base::Sys.getenv()
[15:32:49.716]                 names <- names(envs)
[15:32:49.716]                 common <- intersect(names, old_names)
[15:32:49.716]                 added <- setdiff(names, old_names)
[15:32:49.716]                 removed <- setdiff(old_names, names)
[15:32:49.716]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:49.716]                   envs[common]]
[15:32:49.716]                 NAMES <- toupper(changed)
[15:32:49.716]                 args <- list()
[15:32:49.716]                 for (kk in seq_along(NAMES)) {
[15:32:49.716]                   name <- changed[[kk]]
[15:32:49.716]                   NAME <- NAMES[[kk]]
[15:32:49.716]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.716]                     next
[15:32:49.716]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.716]                 }
[15:32:49.716]                 NAMES <- toupper(added)
[15:32:49.716]                 for (kk in seq_along(NAMES)) {
[15:32:49.716]                   name <- added[[kk]]
[15:32:49.716]                   NAME <- NAMES[[kk]]
[15:32:49.716]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.716]                     next
[15:32:49.716]                   args[[name]] <- ""
[15:32:49.716]                 }
[15:32:49.716]                 NAMES <- toupper(removed)
[15:32:49.716]                 for (kk in seq_along(NAMES)) {
[15:32:49.716]                   name <- removed[[kk]]
[15:32:49.716]                   NAME <- NAMES[[kk]]
[15:32:49.716]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.716]                     next
[15:32:49.716]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.716]                 }
[15:32:49.716]                 if (length(args) > 0) 
[15:32:49.716]                   base::do.call(base::Sys.setenv, args = args)
[15:32:49.716]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:49.716]             }
[15:32:49.716]             else {
[15:32:49.716]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:49.716]             }
[15:32:49.716]             {
[15:32:49.716]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:49.716]                   0L) {
[15:32:49.716]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:49.716]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:49.716]                   base::options(opts)
[15:32:49.716]                 }
[15:32:49.716]                 {
[15:32:49.716]                   {
[15:32:49.716]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:49.716]                     NULL
[15:32:49.716]                   }
[15:32:49.716]                   options(future.plan = NULL)
[15:32:49.716]                   if (is.na(NA_character_)) 
[15:32:49.716]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.716]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:49.716]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:49.716]                     .init = FALSE)
[15:32:49.716]                 }
[15:32:49.716]             }
[15:32:49.716]         }
[15:32:49.716]     })
[15:32:49.716]     if (TRUE) {
[15:32:49.716]         base::sink(type = "output", split = FALSE)
[15:32:49.716]         if (TRUE) {
[15:32:49.716]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:49.716]         }
[15:32:49.716]         else {
[15:32:49.716]             ...future.result["stdout"] <- base::list(NULL)
[15:32:49.716]         }
[15:32:49.716]         base::close(...future.stdout)
[15:32:49.716]         ...future.stdout <- NULL
[15:32:49.716]     }
[15:32:49.716]     ...future.result$conditions <- ...future.conditions
[15:32:49.716]     ...future.result$finished <- base::Sys.time()
[15:32:49.716]     ...future.result
[15:32:49.716] }
[15:32:49.725] Exporting 11 global objects (137.93 KiB) to cluster node #1 ...
[15:32:49.726] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:49.726] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:49.727] Exporting 'x_FUN' (45.86 KiB) to cluster node #1 ...
[15:32:49.727] Exporting 'x_FUN' (45.86 KiB) to cluster node #1 ... DONE
[15:32:49.728] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:49.728] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:49.728] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:49.729] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:49.729] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:49.730] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:49.730] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:49.731] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:49.731] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:49.732] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:49.732] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:49.733] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:49.733] Exporting '...future.elements_ii' (288 bytes) to cluster node #1 ...
[15:32:49.733] Exporting '...future.elements_ii' (288 bytes) to cluster node #1 ... DONE
[15:32:49.734] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:49.734] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:49.735] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:49.735] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:49.736] Exporting 11 global objects (137.93 KiB) to cluster node #1 ... DONE
[15:32:49.736] MultisessionFuture started
[15:32:49.737] - Launch lazy future ... done
[15:32:49.737] run() for 'MultisessionFuture' ... done
[15:32:49.737] Created future:
[15:32:49.769] receiveMessageFromWorker() for ClusterFuture ...
[15:32:49.769] - Validating connection of MultisessionFuture
[15:32:49.770] - received message: FutureResult
[15:32:49.770] - Received FutureResult
[15:32:49.770] - Erased future from FutureRegistry
[15:32:49.771] result() for ClusterFuture ...
[15:32:49.771] - result already collected: FutureResult
[15:32:49.771] result() for ClusterFuture ... done
[15:32:49.772] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:49.737] MultisessionFuture:
[15:32:49.737] Label: 'future_vapply-1'
[15:32:49.737] Expression:
[15:32:49.737] {
[15:32:49.737]     do.call(function(...) {
[15:32:49.737]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.737]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.737]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.737]             on.exit(options(oopts), add = TRUE)
[15:32:49.737]         }
[15:32:49.737]         {
[15:32:49.737]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.737]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.737]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.737]             })
[15:32:49.737]         }
[15:32:49.737]     }, args = future.call.arguments)
[15:32:49.737] }
[15:32:49.737] Lazy evaluation: FALSE
[15:32:49.737] Asynchronous evaluation: TRUE
[15:32:49.737] Local evaluation: TRUE
[15:32:49.737] Environment: R_GlobalEnv
[15:32:49.737] Capture standard output: TRUE
[15:32:49.737] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:49.737] Globals: 11 objects totaling 138.21 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 45.86 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:49.737] Packages: 2 packages ('stats', 'future.apply')
[15:32:49.737] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:49.737] Resolved: TRUE
[15:32:49.737] Value: <not collected>
[15:32:49.737] Conditions captured: <none>
[15:32:49.737] Early signaling: FALSE
[15:32:49.737] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:49.737] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.772] Chunk #1 of 2 ... DONE
[15:32:49.773] Chunk #2 of 2 ...
[15:32:49.773]  - Finding globals in 'X' for chunk #2 ...
[15:32:49.773] getGlobalsAndPackages() ...
[15:32:49.773] Searching for globals...
[15:32:49.774] 
[15:32:49.774] Searching for globals ... DONE
[15:32:49.775] - globals: [0] <none>
[15:32:49.775] getGlobalsAndPackages() ... DONE
[15:32:49.775]    + additional globals found: [n=0] 
[15:32:49.775]    + additional namespaces needed: [n=0] 
[15:32:49.776]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:49.776]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:49.776]  - seeds: <none>
[15:32:49.776]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.777] getGlobalsAndPackages() ...
[15:32:49.777] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.777] Resolving globals: FALSE
[15:32:49.778] Tweak future expression to call with '...' arguments ...
[15:32:49.778] {
[15:32:49.778]     do.call(function(...) {
[15:32:49.778]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.778]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.778]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.778]             on.exit(options(oopts), add = TRUE)
[15:32:49.778]         }
[15:32:49.778]         {
[15:32:49.778]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.778]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.778]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.778]             })
[15:32:49.778]         }
[15:32:49.778]     }, args = future.call.arguments)
[15:32:49.778] }
[15:32:49.779] Tweak future expression to call with '...' arguments ... DONE
[15:32:49.780] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.780] - packages: [2] 'stats', 'future.apply'
[15:32:49.781] getGlobalsAndPackages() ... DONE
[15:32:49.781] run() for 'Future' ...
[15:32:49.782] - state: 'created'
[15:32:49.782] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:49.800] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.801] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:49.801]   - Field: 'node'
[15:32:49.801]   - Field: 'label'
[15:32:49.802]   - Field: 'local'
[15:32:49.802]   - Field: 'owner'
[15:32:49.802]   - Field: 'envir'
[15:32:49.803]   - Field: 'workers'
[15:32:49.803]   - Field: 'packages'
[15:32:49.803]   - Field: 'gc'
[15:32:49.803]   - Field: 'conditions'
[15:32:49.804]   - Field: 'persistent'
[15:32:49.804]   - Field: 'expr'
[15:32:49.804]   - Field: 'uuid'
[15:32:49.805]   - Field: 'seed'
[15:32:49.805]   - Field: 'version'
[15:32:49.805]   - Field: 'result'
[15:32:49.805]   - Field: 'asynchronous'
[15:32:49.805]   - Field: 'calls'
[15:32:49.806]   - Field: 'globals'
[15:32:49.806]   - Field: 'stdout'
[15:32:49.806]   - Field: 'earlySignal'
[15:32:49.806]   - Field: 'lazy'
[15:32:49.806]   - Field: 'state'
[15:32:49.807] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:49.807] - Launch lazy future ...
[15:32:49.807] Packages needed by the future expression (n = 2): 'stats', 'future.apply'
[15:32:49.807] Packages needed by future strategies (n = 0): <none>
[15:32:49.808] {
[15:32:49.808]     {
[15:32:49.808]         {
[15:32:49.808]             ...future.startTime <- base::Sys.time()
[15:32:49.808]             {
[15:32:49.808]                 {
[15:32:49.808]                   {
[15:32:49.808]                     {
[15:32:49.808]                       {
[15:32:49.808]                         base::local({
[15:32:49.808]                           has_future <- base::requireNamespace("future", 
[15:32:49.808]                             quietly = TRUE)
[15:32:49.808]                           if (has_future) {
[15:32:49.808]                             ns <- base::getNamespace("future")
[15:32:49.808]                             version <- ns[[".package"]][["version"]]
[15:32:49.808]                             if (is.null(version)) 
[15:32:49.808]                               version <- utils::packageVersion("future")
[15:32:49.808]                           }
[15:32:49.808]                           else {
[15:32:49.808]                             version <- NULL
[15:32:49.808]                           }
[15:32:49.808]                           if (!has_future || version < "1.8.0") {
[15:32:49.808]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:49.808]                               "", base::R.version$version.string), 
[15:32:49.808]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:49.808]                                 base::R.version$platform, 8 * 
[15:32:49.808]                                   base::.Machine$sizeof.pointer), 
[15:32:49.808]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:49.808]                                 "release", "version")], collapse = " "), 
[15:32:49.808]                               hostname = base::Sys.info()[["nodename"]])
[15:32:49.808]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:49.808]                               info)
[15:32:49.808]                             info <- base::paste(info, collapse = "; ")
[15:32:49.808]                             if (!has_future) {
[15:32:49.808]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:49.808]                                 info)
[15:32:49.808]                             }
[15:32:49.808]                             else {
[15:32:49.808]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:49.808]                                 info, version)
[15:32:49.808]                             }
[15:32:49.808]                             base::stop(msg)
[15:32:49.808]                           }
[15:32:49.808]                         })
[15:32:49.808]                       }
[15:32:49.808]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:49.808]                       base::options(mc.cores = 1L)
[15:32:49.808]                     }
[15:32:49.808]                     base::local({
[15:32:49.808]                       for (pkg in c("stats", "future.apply")) {
[15:32:49.808]                         base::loadNamespace(pkg)
[15:32:49.808]                         base::library(pkg, character.only = TRUE)
[15:32:49.808]                       }
[15:32:49.808]                     })
[15:32:49.808]                   }
[15:32:49.808]                   ...future.strategy.old <- future::plan("list")
[15:32:49.808]                   options(future.plan = NULL)
[15:32:49.808]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.808]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:49.808]                 }
[15:32:49.808]                 ...future.workdir <- getwd()
[15:32:49.808]             }
[15:32:49.808]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:49.808]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:49.808]         }
[15:32:49.808]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:49.808]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:49.808]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:49.808]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:49.808]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:49.808]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:49.808]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:49.808]             base::names(...future.oldOptions))
[15:32:49.808]     }
[15:32:49.808]     if (FALSE) {
[15:32:49.808]     }
[15:32:49.808]     else {
[15:32:49.808]         if (TRUE) {
[15:32:49.808]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:49.808]                 open = "w")
[15:32:49.808]         }
[15:32:49.808]         else {
[15:32:49.808]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:49.808]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:49.808]         }
[15:32:49.808]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:49.808]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:49.808]             base::sink(type = "output", split = FALSE)
[15:32:49.808]             base::close(...future.stdout)
[15:32:49.808]         }, add = TRUE)
[15:32:49.808]     }
[15:32:49.808]     ...future.frame <- base::sys.nframe()
[15:32:49.808]     ...future.conditions <- base::list()
[15:32:49.808]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:49.808]     if (FALSE) {
[15:32:49.808]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:49.808]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:49.808]     }
[15:32:49.808]     ...future.result <- base::tryCatch({
[15:32:49.808]         base::withCallingHandlers({
[15:32:49.808]             ...future.value <- base::withVisible(base::local({
[15:32:49.808]                 ...future.makeSendCondition <- base::local({
[15:32:49.808]                   sendCondition <- NULL
[15:32:49.808]                   function(frame = 1L) {
[15:32:49.808]                     if (is.function(sendCondition)) 
[15:32:49.808]                       return(sendCondition)
[15:32:49.808]                     ns <- getNamespace("parallel")
[15:32:49.808]                     if (exists("sendData", mode = "function", 
[15:32:49.808]                       envir = ns)) {
[15:32:49.808]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:49.808]                         envir = ns)
[15:32:49.808]                       envir <- sys.frame(frame)
[15:32:49.808]                       master <- NULL
[15:32:49.808]                       while (!identical(envir, .GlobalEnv) && 
[15:32:49.808]                         !identical(envir, emptyenv())) {
[15:32:49.808]                         if (exists("master", mode = "list", envir = envir, 
[15:32:49.808]                           inherits = FALSE)) {
[15:32:49.808]                           master <- get("master", mode = "list", 
[15:32:49.808]                             envir = envir, inherits = FALSE)
[15:32:49.808]                           if (inherits(master, c("SOCKnode", 
[15:32:49.808]                             "SOCK0node"))) {
[15:32:49.808]                             sendCondition <<- function(cond) {
[15:32:49.808]                               data <- list(type = "VALUE", value = cond, 
[15:32:49.808]                                 success = TRUE)
[15:32:49.808]                               parallel_sendData(master, data)
[15:32:49.808]                             }
[15:32:49.808]                             return(sendCondition)
[15:32:49.808]                           }
[15:32:49.808]                         }
[15:32:49.808]                         frame <- frame + 1L
[15:32:49.808]                         envir <- sys.frame(frame)
[15:32:49.808]                       }
[15:32:49.808]                     }
[15:32:49.808]                     sendCondition <<- function(cond) NULL
[15:32:49.808]                   }
[15:32:49.808]                 })
[15:32:49.808]                 withCallingHandlers({
[15:32:49.808]                   {
[15:32:49.808]                     do.call(function(...) {
[15:32:49.808]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.808]                       if (!identical(...future.globals.maxSize.org, 
[15:32:49.808]                         ...future.globals.maxSize)) {
[15:32:49.808]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.808]                         on.exit(options(oopts), add = TRUE)
[15:32:49.808]                       }
[15:32:49.808]                       {
[15:32:49.808]                         lapply(seq_along(...future.elements_ii), 
[15:32:49.808]                           FUN = function(jj) {
[15:32:49.808]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.808]                             ...future.FUN(...future.X_jj, ...)
[15:32:49.808]                           })
[15:32:49.808]                       }
[15:32:49.808]                     }, args = future.call.arguments)
[15:32:49.808]                   }
[15:32:49.808]                 }, immediateCondition = function(cond) {
[15:32:49.808]                   sendCondition <- ...future.makeSendCondition()
[15:32:49.808]                   sendCondition(cond)
[15:32:49.808]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.808]                   {
[15:32:49.808]                     inherits <- base::inherits
[15:32:49.808]                     invokeRestart <- base::invokeRestart
[15:32:49.808]                     is.null <- base::is.null
[15:32:49.808]                     muffled <- FALSE
[15:32:49.808]                     if (inherits(cond, "message")) {
[15:32:49.808]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:49.808]                       if (muffled) 
[15:32:49.808]                         invokeRestart("muffleMessage")
[15:32:49.808]                     }
[15:32:49.808]                     else if (inherits(cond, "warning")) {
[15:32:49.808]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:49.808]                       if (muffled) 
[15:32:49.808]                         invokeRestart("muffleWarning")
[15:32:49.808]                     }
[15:32:49.808]                     else if (inherits(cond, "condition")) {
[15:32:49.808]                       if (!is.null(pattern)) {
[15:32:49.808]                         computeRestarts <- base::computeRestarts
[15:32:49.808]                         grepl <- base::grepl
[15:32:49.808]                         restarts <- computeRestarts(cond)
[15:32:49.808]                         for (restart in restarts) {
[15:32:49.808]                           name <- restart$name
[15:32:49.808]                           if (is.null(name)) 
[15:32:49.808]                             next
[15:32:49.808]                           if (!grepl(pattern, name)) 
[15:32:49.808]                             next
[15:32:49.808]                           invokeRestart(restart)
[15:32:49.808]                           muffled <- TRUE
[15:32:49.808]                           break
[15:32:49.808]                         }
[15:32:49.808]                       }
[15:32:49.808]                     }
[15:32:49.808]                     invisible(muffled)
[15:32:49.808]                   }
[15:32:49.808]                   muffleCondition(cond)
[15:32:49.808]                 })
[15:32:49.808]             }))
[15:32:49.808]             future::FutureResult(value = ...future.value$value, 
[15:32:49.808]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.808]                   ...future.rng), globalenv = if (FALSE) 
[15:32:49.808]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:49.808]                     ...future.globalenv.names))
[15:32:49.808]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:49.808]         }, condition = base::local({
[15:32:49.808]             c <- base::c
[15:32:49.808]             inherits <- base::inherits
[15:32:49.808]             invokeRestart <- base::invokeRestart
[15:32:49.808]             length <- base::length
[15:32:49.808]             list <- base::list
[15:32:49.808]             seq.int <- base::seq.int
[15:32:49.808]             signalCondition <- base::signalCondition
[15:32:49.808]             sys.calls <- base::sys.calls
[15:32:49.808]             `[[` <- base::`[[`
[15:32:49.808]             `+` <- base::`+`
[15:32:49.808]             `<<-` <- base::`<<-`
[15:32:49.808]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:49.808]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:49.808]                   3L)]
[15:32:49.808]             }
[15:32:49.808]             function(cond) {
[15:32:49.808]                 is_error <- inherits(cond, "error")
[15:32:49.808]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:49.808]                   NULL)
[15:32:49.808]                 if (is_error) {
[15:32:49.808]                   sessionInformation <- function() {
[15:32:49.808]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:49.808]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:49.808]                       search = base::search(), system = base::Sys.info())
[15:32:49.808]                   }
[15:32:49.808]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.808]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:49.808]                     cond$call), session = sessionInformation(), 
[15:32:49.808]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:49.808]                   signalCondition(cond)
[15:32:49.808]                 }
[15:32:49.808]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:49.808]                 "immediateCondition"))) {
[15:32:49.808]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:49.808]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.808]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:49.808]                   if (TRUE && !signal) {
[15:32:49.808]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.808]                     {
[15:32:49.808]                       inherits <- base::inherits
[15:32:49.808]                       invokeRestart <- base::invokeRestart
[15:32:49.808]                       is.null <- base::is.null
[15:32:49.808]                       muffled <- FALSE
[15:32:49.808]                       if (inherits(cond, "message")) {
[15:32:49.808]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.808]                         if (muffled) 
[15:32:49.808]                           invokeRestart("muffleMessage")
[15:32:49.808]                       }
[15:32:49.808]                       else if (inherits(cond, "warning")) {
[15:32:49.808]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.808]                         if (muffled) 
[15:32:49.808]                           invokeRestart("muffleWarning")
[15:32:49.808]                       }
[15:32:49.808]                       else if (inherits(cond, "condition")) {
[15:32:49.808]                         if (!is.null(pattern)) {
[15:32:49.808]                           computeRestarts <- base::computeRestarts
[15:32:49.808]                           grepl <- base::grepl
[15:32:49.808]                           restarts <- computeRestarts(cond)
[15:32:49.808]                           for (restart in restarts) {
[15:32:49.808]                             name <- restart$name
[15:32:49.808]                             if (is.null(name)) 
[15:32:49.808]                               next
[15:32:49.808]                             if (!grepl(pattern, name)) 
[15:32:49.808]                               next
[15:32:49.808]                             invokeRestart(restart)
[15:32:49.808]                             muffled <- TRUE
[15:32:49.808]                             break
[15:32:49.808]                           }
[15:32:49.808]                         }
[15:32:49.808]                       }
[15:32:49.808]                       invisible(muffled)
[15:32:49.808]                     }
[15:32:49.808]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.808]                   }
[15:32:49.808]                 }
[15:32:49.808]                 else {
[15:32:49.808]                   if (TRUE) {
[15:32:49.808]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.808]                     {
[15:32:49.808]                       inherits <- base::inherits
[15:32:49.808]                       invokeRestart <- base::invokeRestart
[15:32:49.808]                       is.null <- base::is.null
[15:32:49.808]                       muffled <- FALSE
[15:32:49.808]                       if (inherits(cond, "message")) {
[15:32:49.808]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.808]                         if (muffled) 
[15:32:49.808]                           invokeRestart("muffleMessage")
[15:32:49.808]                       }
[15:32:49.808]                       else if (inherits(cond, "warning")) {
[15:32:49.808]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.808]                         if (muffled) 
[15:32:49.808]                           invokeRestart("muffleWarning")
[15:32:49.808]                       }
[15:32:49.808]                       else if (inherits(cond, "condition")) {
[15:32:49.808]                         if (!is.null(pattern)) {
[15:32:49.808]                           computeRestarts <- base::computeRestarts
[15:32:49.808]                           grepl <- base::grepl
[15:32:49.808]                           restarts <- computeRestarts(cond)
[15:32:49.808]                           for (restart in restarts) {
[15:32:49.808]                             name <- restart$name
[15:32:49.808]                             if (is.null(name)) 
[15:32:49.808]                               next
[15:32:49.808]                             if (!grepl(pattern, name)) 
[15:32:49.808]                               next
[15:32:49.808]                             invokeRestart(restart)
[15:32:49.808]                             muffled <- TRUE
[15:32:49.808]                             break
[15:32:49.808]                           }
[15:32:49.808]                         }
[15:32:49.808]                       }
[15:32:49.808]                       invisible(muffled)
[15:32:49.808]                     }
[15:32:49.808]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.808]                   }
[15:32:49.808]                 }
[15:32:49.808]             }
[15:32:49.808]         }))
[15:32:49.808]     }, error = function(ex) {
[15:32:49.808]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:49.808]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.808]                 ...future.rng), started = ...future.startTime, 
[15:32:49.808]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:49.808]             version = "1.8"), class = "FutureResult")
[15:32:49.808]     }, finally = {
[15:32:49.808]         if (!identical(...future.workdir, getwd())) 
[15:32:49.808]             setwd(...future.workdir)
[15:32:49.808]         {
[15:32:49.808]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:49.808]                 ...future.oldOptions$nwarnings <- NULL
[15:32:49.808]             }
[15:32:49.808]             base::options(...future.oldOptions)
[15:32:49.808]             if (.Platform$OS.type == "windows") {
[15:32:49.808]                 old_names <- names(...future.oldEnvVars)
[15:32:49.808]                 envs <- base::Sys.getenv()
[15:32:49.808]                 names <- names(envs)
[15:32:49.808]                 common <- intersect(names, old_names)
[15:32:49.808]                 added <- setdiff(names, old_names)
[15:32:49.808]                 removed <- setdiff(old_names, names)
[15:32:49.808]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:49.808]                   envs[common]]
[15:32:49.808]                 NAMES <- toupper(changed)
[15:32:49.808]                 args <- list()
[15:32:49.808]                 for (kk in seq_along(NAMES)) {
[15:32:49.808]                   name <- changed[[kk]]
[15:32:49.808]                   NAME <- NAMES[[kk]]
[15:32:49.808]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.808]                     next
[15:32:49.808]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.808]                 }
[15:32:49.808]                 NAMES <- toupper(added)
[15:32:49.808]                 for (kk in seq_along(NAMES)) {
[15:32:49.808]                   name <- added[[kk]]
[15:32:49.808]                   NAME <- NAMES[[kk]]
[15:32:49.808]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.808]                     next
[15:32:49.808]                   args[[name]] <- ""
[15:32:49.808]                 }
[15:32:49.808]                 NAMES <- toupper(removed)
[15:32:49.808]                 for (kk in seq_along(NAMES)) {
[15:32:49.808]                   name <- removed[[kk]]
[15:32:49.808]                   NAME <- NAMES[[kk]]
[15:32:49.808]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.808]                     next
[15:32:49.808]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.808]                 }
[15:32:49.808]                 if (length(args) > 0) 
[15:32:49.808]                   base::do.call(base::Sys.setenv, args = args)
[15:32:49.808]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:49.808]             }
[15:32:49.808]             else {
[15:32:49.808]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:49.808]             }
[15:32:49.808]             {
[15:32:49.808]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:49.808]                   0L) {
[15:32:49.808]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:49.808]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:49.808]                   base::options(opts)
[15:32:49.808]                 }
[15:32:49.808]                 {
[15:32:49.808]                   {
[15:32:49.808]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:49.808]                     NULL
[15:32:49.808]                   }
[15:32:49.808]                   options(future.plan = NULL)
[15:32:49.808]                   if (is.na(NA_character_)) 
[15:32:49.808]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.808]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:49.808]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:49.808]                     .init = FALSE)
[15:32:49.808]                 }
[15:32:49.808]             }
[15:32:49.808]         }
[15:32:49.808]     })
[15:32:49.808]     if (TRUE) {
[15:32:49.808]         base::sink(type = "output", split = FALSE)
[15:32:49.808]         if (TRUE) {
[15:32:49.808]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:49.808]         }
[15:32:49.808]         else {
[15:32:49.808]             ...future.result["stdout"] <- base::list(NULL)
[15:32:49.808]         }
[15:32:49.808]         base::close(...future.stdout)
[15:32:49.808]         ...future.stdout <- NULL
[15:32:49.808]     }
[15:32:49.808]     ...future.result$conditions <- ...future.conditions
[15:32:49.808]     ...future.result$finished <- base::Sys.time()
[15:32:49.808]     ...future.result
[15:32:49.808] }
[15:32:49.814] Exporting 11 global objects (137.93 KiB) to cluster node #1 ...
[15:32:49.814] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:49.815] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:49.815] Exporting 'x_FUN' (45.86 KiB) to cluster node #1 ...
[15:32:49.816] Exporting 'x_FUN' (45.86 KiB) to cluster node #1 ... DONE
[15:32:49.816] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:49.816] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:49.817] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:49.817] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:49.817] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:49.818] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:49.818] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:49.818] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:49.819] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:49.819] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:49.819] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:49.820] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:49.820] Exporting '...future.elements_ii' (256 bytes) to cluster node #1 ...
[15:32:49.821] Exporting '...future.elements_ii' (256 bytes) to cluster node #1 ... DONE
[15:32:49.821] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:49.821] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:49.821] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:49.822] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:49.822] Exporting 11 global objects (137.93 KiB) to cluster node #1 ... DONE
[15:32:49.823] MultisessionFuture started
[15:32:49.823] - Launch lazy future ... done
[15:32:49.823] run() for 'MultisessionFuture' ... done
[15:32:49.823] Created future:
[15:32:49.841] receiveMessageFromWorker() for ClusterFuture ...
[15:32:49.841] - Validating connection of MultisessionFuture
[15:32:49.841] - received message: FutureResult
[15:32:49.842] - Received FutureResult
[15:32:49.842] - Erased future from FutureRegistry
[15:32:49.842] result() for ClusterFuture ...
[15:32:49.842] - result already collected: FutureResult
[15:32:49.842] result() for ClusterFuture ... done
[15:32:49.843] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:49.823] MultisessionFuture:
[15:32:49.823] Label: 'future_vapply-2'
[15:32:49.823] Expression:
[15:32:49.823] {
[15:32:49.823]     do.call(function(...) {
[15:32:49.823]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.823]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.823]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.823]             on.exit(options(oopts), add = TRUE)
[15:32:49.823]         }
[15:32:49.823]         {
[15:32:49.823]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.823]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.823]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.823]             })
[15:32:49.823]         }
[15:32:49.823]     }, args = future.call.arguments)
[15:32:49.823] }
[15:32:49.823] Lazy evaluation: FALSE
[15:32:49.823] Asynchronous evaluation: TRUE
[15:32:49.823] Local evaluation: TRUE
[15:32:49.823] Environment: R_GlobalEnv
[15:32:49.823] Capture standard output: TRUE
[15:32:49.823] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:49.823] Globals: 11 objects totaling 138.18 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 45.86 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:49.823] Packages: 2 packages ('stats', 'future.apply')
[15:32:49.823] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:49.823] Resolved: TRUE
[15:32:49.823] Value: <not collected>
[15:32:49.823] Conditions captured: <none>
[15:32:49.823] Early signaling: FALSE
[15:32:49.823] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:49.823] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.843] Chunk #2 of 2 ... DONE
[15:32:49.843] Launching 2 futures (chunks) ... DONE
[15:32:49.843] Resolving 2 futures (chunks) ...
[15:32:49.844] resolve() on list ...
[15:32:49.844]  recursive: 0
[15:32:49.844]  length: 2
[15:32:49.844] 
[15:32:49.844] Future #1
[15:32:49.845] result() for ClusterFuture ...
[15:32:49.845] - result already collected: FutureResult
[15:32:49.845] result() for ClusterFuture ... done
[15:32:49.845] result() for ClusterFuture ...
[15:32:49.845] - result already collected: FutureResult
[15:32:49.845] result() for ClusterFuture ... done
[15:32:49.846] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:49.846] - nx: 2
[15:32:49.846] - relay: TRUE
[15:32:49.846] - stdout: TRUE
[15:32:49.846] - signal: TRUE
[15:32:49.846] - resignal: FALSE
[15:32:49.846] - force: TRUE
[15:32:49.847] - relayed: [n=2] FALSE, FALSE
[15:32:49.847] - queued futures: [n=2] FALSE, FALSE
[15:32:49.847]  - until=1
[15:32:49.847]  - relaying element #1
[15:32:49.847] result() for ClusterFuture ...
[15:32:49.847] - result already collected: FutureResult
[15:32:49.848] result() for ClusterFuture ... done
[15:32:49.848] result() for ClusterFuture ...
[15:32:49.848] - result already collected: FutureResult
[15:32:49.848] result() for ClusterFuture ... done
[15:32:49.848] result() for ClusterFuture ...
[15:32:49.849] - result already collected: FutureResult
[15:32:49.849] result() for ClusterFuture ... done
[15:32:49.849] result() for ClusterFuture ...
[15:32:49.849] - result already collected: FutureResult
[15:32:49.849] result() for ClusterFuture ... done
[15:32:49.849] - relayed: [n=2] TRUE, FALSE
[15:32:49.850] - queued futures: [n=2] TRUE, FALSE
[15:32:49.850] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:49.850]  length: 1 (resolved future 1)
[15:32:49.850] Future #2
[15:32:49.850] result() for ClusterFuture ...
[15:32:49.850] - result already collected: FutureResult
[15:32:49.851] result() for ClusterFuture ... done
[15:32:49.851] result() for ClusterFuture ...
[15:32:49.851] - result already collected: FutureResult
[15:32:49.851] result() for ClusterFuture ... done
[15:32:49.851] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:49.852] - nx: 2
[15:32:49.852] - relay: TRUE
[15:32:49.852] - stdout: TRUE
[15:32:49.852] - signal: TRUE
[15:32:49.852] - resignal: FALSE
[15:32:49.852] - force: TRUE
[15:32:49.853] - relayed: [n=2] TRUE, FALSE
[15:32:49.853] - queued futures: [n=2] TRUE, FALSE
[15:32:49.853]  - until=2
[15:32:49.856]  - relaying element #2
[15:32:49.856] result() for ClusterFuture ...
[15:32:49.856] - result already collected: FutureResult
[15:32:49.856] result() for ClusterFuture ... done
[15:32:49.856] result() for ClusterFuture ...
[15:32:49.857] - result already collected: FutureResult
[15:32:49.857] result() for ClusterFuture ... done
[15:32:49.857] result() for ClusterFuture ...
[15:32:49.857] - result already collected: FutureResult
[15:32:49.857] result() for ClusterFuture ... done
[15:32:49.857] result() for ClusterFuture ...
[15:32:49.858] - result already collected: FutureResult
[15:32:49.858] result() for ClusterFuture ... done
[15:32:49.858] - relayed: [n=2] TRUE, TRUE
[15:32:49.858] - queued futures: [n=2] TRUE, TRUE
[15:32:49.858] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:49.858]  length: 0 (resolved future 2)
[15:32:49.859] Relaying remaining futures
[15:32:49.859] signalConditionsASAP(NULL, pos=0) ...
[15:32:49.859] - nx: 2
[15:32:49.859] - relay: TRUE
[15:32:49.859] - stdout: TRUE
[15:32:49.859] - signal: TRUE
[15:32:49.860] - resignal: FALSE
[15:32:49.860] - force: TRUE
[15:32:49.860] - relayed: [n=2] TRUE, TRUE
[15:32:49.860] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:49.860] - relayed: [n=2] TRUE, TRUE
[15:32:49.861] - queued futures: [n=2] TRUE, TRUE
[15:32:49.861] signalConditionsASAP(NULL, pos=0) ... done
[15:32:49.861] resolve() on list ... DONE
[15:32:49.862] result() for ClusterFuture ...
[15:32:49.862] - result already collected: FutureResult
[15:32:49.862] result() for ClusterFuture ... done
[15:32:49.862] result() for ClusterFuture ...
[15:32:49.863] - result already collected: FutureResult
[15:32:49.863] result() for ClusterFuture ... done
[15:32:49.863] result() for ClusterFuture ...
[15:32:49.864] - result already collected: FutureResult
[15:32:49.864] result() for ClusterFuture ... done
[15:32:49.864] result() for ClusterFuture ...
[15:32:49.865] - result already collected: FutureResult
[15:32:49.865] result() for ClusterFuture ... done
[15:32:49.865]  - Number of value chunks collected: 2
[15:32:49.866] Resolving 2 futures (chunks) ... DONE
[15:32:49.866] Reducing values from 2 chunks ...
[15:32:49.866]  - Number of values collected after concatenation: 7
[15:32:49.866]  - Number of values expected: 7
[15:32:49.867] Reducing values from 2 chunks ... DONE
[15:32:49.867] future_lapply() ... DONE
 num [1:5, 1:7] 1 1.5 2 2.5 3 1 1.5 2.5 3.5 4 ...
 - attr(*, "dimnames")=List of 2
  ..$ : chr [1:5] "Min." "1st Qu." "Median" "3rd Qu." ...
  ..$ : NULL
[15:32:49.870] future_lapply() ...
[15:32:49.875] Number of chunks: 2
[15:32:49.876] getGlobalsAndPackagesXApply() ...
[15:32:49.876]  - future.globals: TRUE
[15:32:49.876] getGlobalsAndPackages() ...
[15:32:49.877] Searching for globals...
[15:32:49.879] - globals found: [3] 'FUN', 'outer', 'rep'
[15:32:49.880] Searching for globals ... DONE
[15:32:49.880] Resolving globals: FALSE
[15:32:49.881] The total size of the 1 globals is 4.07 KiB (4168 bytes)
[15:32:49.882] The total size of the 1 globals exported for future expression ('FUN(y = c(2, 4, 6, 8, 10))') is 4.07 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.07 KiB of class 'function')
[15:32:49.882] - globals: [1] 'FUN'
[15:32:49.882] 
[15:32:49.883] getGlobalsAndPackages() ... DONE
[15:32:49.883]  - globals found/used: [n=1] 'FUN'
[15:32:49.883]  - needed namespaces: [n=0] 
[15:32:49.883] Finding globals ... DONE
[15:32:49.884]  - use_args: TRUE
[15:32:49.884]  - Getting '...' globals ...
[15:32:49.885] resolve() on list ...
[15:32:49.885]  recursive: 0
[15:32:49.885]  length: 1
[15:32:49.886]  elements: '...'
[15:32:49.886]  length: 0 (resolved future 1)
[15:32:49.886] resolve() on list ... DONE
[15:32:49.887]    - '...' content: [n=1] 'y'
[15:32:49.887] List of 1
[15:32:49.887]  $ ...:List of 1
[15:32:49.887]   ..$ y: num [1:5] 2 4 6 8 10
[15:32:49.887]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:49.887]  - attr(*, "where")=List of 1
[15:32:49.887]   ..$ ...:<environment: 0x0000022d3e62c8b8> 
[15:32:49.887]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:49.887]  - attr(*, "resolved")= logi TRUE
[15:32:49.887]  - attr(*, "total_size")= num NA
[15:32:49.893]  - Getting '...' globals ... DONE
[15:32:49.894] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:32:49.894] List of 2
[15:32:49.894]  $ ...future.FUN:function (x, y)  
[15:32:49.894]  $ ...          :List of 1
[15:32:49.894]   ..$ y: num [1:5] 2 4 6 8 10
[15:32:49.894]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:49.894]  - attr(*, "where")=List of 2
[15:32:49.894]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:49.894]   ..$ ...          :<environment: 0x0000022d3e62c8b8> 
[15:32:49.894]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:49.894]  - attr(*, "resolved")= logi FALSE
[15:32:49.894]  - attr(*, "total_size")= num 4264
[15:32:49.900] Packages to be attached in all futures: [n=0] 
[15:32:49.901] getGlobalsAndPackagesXApply() ... DONE
[15:32:49.901] Number of futures (= number of chunks): 2
[15:32:49.902] Launching 2 futures (chunks) ...
[15:32:49.902] Chunk #1 of 2 ...
[15:32:49.902]  - Finding globals in 'X' for chunk #1 ...
[15:32:49.903] getGlobalsAndPackages() ...
[15:32:49.903] Searching for globals...
[15:32:49.903] 
[15:32:49.904] Searching for globals ... DONE
[15:32:49.904] - globals: [0] <none>
[15:32:49.904] getGlobalsAndPackages() ... DONE
[15:32:49.905]    + additional globals found: [n=0] 
[15:32:49.905]    + additional namespaces needed: [n=0] 
[15:32:49.905]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:49.906]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:49.906]  - seeds: <none>
[15:32:49.906]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.906] getGlobalsAndPackages() ...
[15:32:49.907] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.907] Resolving globals: FALSE
[15:32:49.907] Tweak future expression to call with '...' arguments ...
[15:32:49.908] {
[15:32:49.908]     do.call(function(...) {
[15:32:49.908]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.908]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.908]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.908]             on.exit(options(oopts), add = TRUE)
[15:32:49.908]         }
[15:32:49.908]         {
[15:32:49.908]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.908]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.908]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.908]             })
[15:32:49.908]         }
[15:32:49.908]     }, args = future.call.arguments)
[15:32:49.908] }
[15:32:49.909] Tweak future expression to call with '...' arguments ... DONE
[15:32:49.909] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.910] 
[15:32:49.910] getGlobalsAndPackages() ... DONE
[15:32:49.911] run() for 'Future' ...
[15:32:49.911] - state: 'created'
[15:32:49.912] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:49.930] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.931] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:49.931]   - Field: 'node'
[15:32:49.931]   - Field: 'label'
[15:32:49.932]   - Field: 'local'
[15:32:49.932]   - Field: 'owner'
[15:32:49.932]   - Field: 'envir'
[15:32:49.933]   - Field: 'workers'
[15:32:49.933]   - Field: 'packages'
[15:32:49.933]   - Field: 'gc'
[15:32:49.934]   - Field: 'conditions'
[15:32:49.934]   - Field: 'persistent'
[15:32:49.934]   - Field: 'expr'
[15:32:49.935]   - Field: 'uuid'
[15:32:49.935]   - Field: 'seed'
[15:32:49.935]   - Field: 'version'
[15:32:49.936]   - Field: 'result'
[15:32:49.936]   - Field: 'asynchronous'
[15:32:49.936]   - Field: 'calls'
[15:32:49.937]   - Field: 'globals'
[15:32:49.937]   - Field: 'stdout'
[15:32:49.937]   - Field: 'earlySignal'
[15:32:49.938]   - Field: 'lazy'
[15:32:49.938]   - Field: 'state'
[15:32:49.938] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:49.939] - Launch lazy future ...
[15:32:49.939] Packages needed by the future expression (n = 0): <none>
[15:32:49.940] Packages needed by future strategies (n = 0): <none>
[15:32:49.941] {
[15:32:49.941]     {
[15:32:49.941]         {
[15:32:49.941]             ...future.startTime <- base::Sys.time()
[15:32:49.941]             {
[15:32:49.941]                 {
[15:32:49.941]                   {
[15:32:49.941]                     {
[15:32:49.941]                       base::local({
[15:32:49.941]                         has_future <- base::requireNamespace("future", 
[15:32:49.941]                           quietly = TRUE)
[15:32:49.941]                         if (has_future) {
[15:32:49.941]                           ns <- base::getNamespace("future")
[15:32:49.941]                           version <- ns[[".package"]][["version"]]
[15:32:49.941]                           if (is.null(version)) 
[15:32:49.941]                             version <- utils::packageVersion("future")
[15:32:49.941]                         }
[15:32:49.941]                         else {
[15:32:49.941]                           version <- NULL
[15:32:49.941]                         }
[15:32:49.941]                         if (!has_future || version < "1.8.0") {
[15:32:49.941]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:49.941]                             "", base::R.version$version.string), 
[15:32:49.941]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:49.941]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:49.941]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:49.941]                               "release", "version")], collapse = " "), 
[15:32:49.941]                             hostname = base::Sys.info()[["nodename"]])
[15:32:49.941]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:49.941]                             info)
[15:32:49.941]                           info <- base::paste(info, collapse = "; ")
[15:32:49.941]                           if (!has_future) {
[15:32:49.941]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:49.941]                               info)
[15:32:49.941]                           }
[15:32:49.941]                           else {
[15:32:49.941]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:49.941]                               info, version)
[15:32:49.941]                           }
[15:32:49.941]                           base::stop(msg)
[15:32:49.941]                         }
[15:32:49.941]                       })
[15:32:49.941]                     }
[15:32:49.941]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:49.941]                     base::options(mc.cores = 1L)
[15:32:49.941]                   }
[15:32:49.941]                   ...future.strategy.old <- future::plan("list")
[15:32:49.941]                   options(future.plan = NULL)
[15:32:49.941]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.941]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:49.941]                 }
[15:32:49.941]                 ...future.workdir <- getwd()
[15:32:49.941]             }
[15:32:49.941]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:49.941]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:49.941]         }
[15:32:49.941]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:49.941]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:49.941]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:49.941]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:49.941]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:49.941]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:49.941]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:49.941]             base::names(...future.oldOptions))
[15:32:49.941]     }
[15:32:49.941]     if (FALSE) {
[15:32:49.941]     }
[15:32:49.941]     else {
[15:32:49.941]         if (TRUE) {
[15:32:49.941]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:49.941]                 open = "w")
[15:32:49.941]         }
[15:32:49.941]         else {
[15:32:49.941]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:49.941]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:49.941]         }
[15:32:49.941]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:49.941]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:49.941]             base::sink(type = "output", split = FALSE)
[15:32:49.941]             base::close(...future.stdout)
[15:32:49.941]         }, add = TRUE)
[15:32:49.941]     }
[15:32:49.941]     ...future.frame <- base::sys.nframe()
[15:32:49.941]     ...future.conditions <- base::list()
[15:32:49.941]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:49.941]     if (FALSE) {
[15:32:49.941]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:49.941]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:49.941]     }
[15:32:49.941]     ...future.result <- base::tryCatch({
[15:32:49.941]         base::withCallingHandlers({
[15:32:49.941]             ...future.value <- base::withVisible(base::local({
[15:32:49.941]                 ...future.makeSendCondition <- base::local({
[15:32:49.941]                   sendCondition <- NULL
[15:32:49.941]                   function(frame = 1L) {
[15:32:49.941]                     if (is.function(sendCondition)) 
[15:32:49.941]                       return(sendCondition)
[15:32:49.941]                     ns <- getNamespace("parallel")
[15:32:49.941]                     if (exists("sendData", mode = "function", 
[15:32:49.941]                       envir = ns)) {
[15:32:49.941]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:49.941]                         envir = ns)
[15:32:49.941]                       envir <- sys.frame(frame)
[15:32:49.941]                       master <- NULL
[15:32:49.941]                       while (!identical(envir, .GlobalEnv) && 
[15:32:49.941]                         !identical(envir, emptyenv())) {
[15:32:49.941]                         if (exists("master", mode = "list", envir = envir, 
[15:32:49.941]                           inherits = FALSE)) {
[15:32:49.941]                           master <- get("master", mode = "list", 
[15:32:49.941]                             envir = envir, inherits = FALSE)
[15:32:49.941]                           if (inherits(master, c("SOCKnode", 
[15:32:49.941]                             "SOCK0node"))) {
[15:32:49.941]                             sendCondition <<- function(cond) {
[15:32:49.941]                               data <- list(type = "VALUE", value = cond, 
[15:32:49.941]                                 success = TRUE)
[15:32:49.941]                               parallel_sendData(master, data)
[15:32:49.941]                             }
[15:32:49.941]                             return(sendCondition)
[15:32:49.941]                           }
[15:32:49.941]                         }
[15:32:49.941]                         frame <- frame + 1L
[15:32:49.941]                         envir <- sys.frame(frame)
[15:32:49.941]                       }
[15:32:49.941]                     }
[15:32:49.941]                     sendCondition <<- function(cond) NULL
[15:32:49.941]                   }
[15:32:49.941]                 })
[15:32:49.941]                 withCallingHandlers({
[15:32:49.941]                   {
[15:32:49.941]                     do.call(function(...) {
[15:32:49.941]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.941]                       if (!identical(...future.globals.maxSize.org, 
[15:32:49.941]                         ...future.globals.maxSize)) {
[15:32:49.941]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.941]                         on.exit(options(oopts), add = TRUE)
[15:32:49.941]                       }
[15:32:49.941]                       {
[15:32:49.941]                         lapply(seq_along(...future.elements_ii), 
[15:32:49.941]                           FUN = function(jj) {
[15:32:49.941]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.941]                             ...future.FUN(...future.X_jj, ...)
[15:32:49.941]                           })
[15:32:49.941]                       }
[15:32:49.941]                     }, args = future.call.arguments)
[15:32:49.941]                   }
[15:32:49.941]                 }, immediateCondition = function(cond) {
[15:32:49.941]                   sendCondition <- ...future.makeSendCondition()
[15:32:49.941]                   sendCondition(cond)
[15:32:49.941]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.941]                   {
[15:32:49.941]                     inherits <- base::inherits
[15:32:49.941]                     invokeRestart <- base::invokeRestart
[15:32:49.941]                     is.null <- base::is.null
[15:32:49.941]                     muffled <- FALSE
[15:32:49.941]                     if (inherits(cond, "message")) {
[15:32:49.941]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:49.941]                       if (muffled) 
[15:32:49.941]                         invokeRestart("muffleMessage")
[15:32:49.941]                     }
[15:32:49.941]                     else if (inherits(cond, "warning")) {
[15:32:49.941]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:49.941]                       if (muffled) 
[15:32:49.941]                         invokeRestart("muffleWarning")
[15:32:49.941]                     }
[15:32:49.941]                     else if (inherits(cond, "condition")) {
[15:32:49.941]                       if (!is.null(pattern)) {
[15:32:49.941]                         computeRestarts <- base::computeRestarts
[15:32:49.941]                         grepl <- base::grepl
[15:32:49.941]                         restarts <- computeRestarts(cond)
[15:32:49.941]                         for (restart in restarts) {
[15:32:49.941]                           name <- restart$name
[15:32:49.941]                           if (is.null(name)) 
[15:32:49.941]                             next
[15:32:49.941]                           if (!grepl(pattern, name)) 
[15:32:49.941]                             next
[15:32:49.941]                           invokeRestart(restart)
[15:32:49.941]                           muffled <- TRUE
[15:32:49.941]                           break
[15:32:49.941]                         }
[15:32:49.941]                       }
[15:32:49.941]                     }
[15:32:49.941]                     invisible(muffled)
[15:32:49.941]                   }
[15:32:49.941]                   muffleCondition(cond)
[15:32:49.941]                 })
[15:32:49.941]             }))
[15:32:49.941]             future::FutureResult(value = ...future.value$value, 
[15:32:49.941]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.941]                   ...future.rng), globalenv = if (FALSE) 
[15:32:49.941]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:49.941]                     ...future.globalenv.names))
[15:32:49.941]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:49.941]         }, condition = base::local({
[15:32:49.941]             c <- base::c
[15:32:49.941]             inherits <- base::inherits
[15:32:49.941]             invokeRestart <- base::invokeRestart
[15:32:49.941]             length <- base::length
[15:32:49.941]             list <- base::list
[15:32:49.941]             seq.int <- base::seq.int
[15:32:49.941]             signalCondition <- base::signalCondition
[15:32:49.941]             sys.calls <- base::sys.calls
[15:32:49.941]             `[[` <- base::`[[`
[15:32:49.941]             `+` <- base::`+`
[15:32:49.941]             `<<-` <- base::`<<-`
[15:32:49.941]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:49.941]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:49.941]                   3L)]
[15:32:49.941]             }
[15:32:49.941]             function(cond) {
[15:32:49.941]                 is_error <- inherits(cond, "error")
[15:32:49.941]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:49.941]                   NULL)
[15:32:49.941]                 if (is_error) {
[15:32:49.941]                   sessionInformation <- function() {
[15:32:49.941]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:49.941]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:49.941]                       search = base::search(), system = base::Sys.info())
[15:32:49.941]                   }
[15:32:49.941]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.941]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:49.941]                     cond$call), session = sessionInformation(), 
[15:32:49.941]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:49.941]                   signalCondition(cond)
[15:32:49.941]                 }
[15:32:49.941]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:49.941]                 "immediateCondition"))) {
[15:32:49.941]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:49.941]                   ...future.conditions[[length(...future.conditions) + 
[15:32:49.941]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:49.941]                   if (TRUE && !signal) {
[15:32:49.941]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.941]                     {
[15:32:49.941]                       inherits <- base::inherits
[15:32:49.941]                       invokeRestart <- base::invokeRestart
[15:32:49.941]                       is.null <- base::is.null
[15:32:49.941]                       muffled <- FALSE
[15:32:49.941]                       if (inherits(cond, "message")) {
[15:32:49.941]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.941]                         if (muffled) 
[15:32:49.941]                           invokeRestart("muffleMessage")
[15:32:49.941]                       }
[15:32:49.941]                       else if (inherits(cond, "warning")) {
[15:32:49.941]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.941]                         if (muffled) 
[15:32:49.941]                           invokeRestart("muffleWarning")
[15:32:49.941]                       }
[15:32:49.941]                       else if (inherits(cond, "condition")) {
[15:32:49.941]                         if (!is.null(pattern)) {
[15:32:49.941]                           computeRestarts <- base::computeRestarts
[15:32:49.941]                           grepl <- base::grepl
[15:32:49.941]                           restarts <- computeRestarts(cond)
[15:32:49.941]                           for (restart in restarts) {
[15:32:49.941]                             name <- restart$name
[15:32:49.941]                             if (is.null(name)) 
[15:32:49.941]                               next
[15:32:49.941]                             if (!grepl(pattern, name)) 
[15:32:49.941]                               next
[15:32:49.941]                             invokeRestart(restart)
[15:32:49.941]                             muffled <- TRUE
[15:32:49.941]                             break
[15:32:49.941]                           }
[15:32:49.941]                         }
[15:32:49.941]                       }
[15:32:49.941]                       invisible(muffled)
[15:32:49.941]                     }
[15:32:49.941]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.941]                   }
[15:32:49.941]                 }
[15:32:49.941]                 else {
[15:32:49.941]                   if (TRUE) {
[15:32:49.941]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:49.941]                     {
[15:32:49.941]                       inherits <- base::inherits
[15:32:49.941]                       invokeRestart <- base::invokeRestart
[15:32:49.941]                       is.null <- base::is.null
[15:32:49.941]                       muffled <- FALSE
[15:32:49.941]                       if (inherits(cond, "message")) {
[15:32:49.941]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:49.941]                         if (muffled) 
[15:32:49.941]                           invokeRestart("muffleMessage")
[15:32:49.941]                       }
[15:32:49.941]                       else if (inherits(cond, "warning")) {
[15:32:49.941]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:49.941]                         if (muffled) 
[15:32:49.941]                           invokeRestart("muffleWarning")
[15:32:49.941]                       }
[15:32:49.941]                       else if (inherits(cond, "condition")) {
[15:32:49.941]                         if (!is.null(pattern)) {
[15:32:49.941]                           computeRestarts <- base::computeRestarts
[15:32:49.941]                           grepl <- base::grepl
[15:32:49.941]                           restarts <- computeRestarts(cond)
[15:32:49.941]                           for (restart in restarts) {
[15:32:49.941]                             name <- restart$name
[15:32:49.941]                             if (is.null(name)) 
[15:32:49.941]                               next
[15:32:49.941]                             if (!grepl(pattern, name)) 
[15:32:49.941]                               next
[15:32:49.941]                             invokeRestart(restart)
[15:32:49.941]                             muffled <- TRUE
[15:32:49.941]                             break
[15:32:49.941]                           }
[15:32:49.941]                         }
[15:32:49.941]                       }
[15:32:49.941]                       invisible(muffled)
[15:32:49.941]                     }
[15:32:49.941]                     muffleCondition(cond, pattern = "^muffle")
[15:32:49.941]                   }
[15:32:49.941]                 }
[15:32:49.941]             }
[15:32:49.941]         }))
[15:32:49.941]     }, error = function(ex) {
[15:32:49.941]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:49.941]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:49.941]                 ...future.rng), started = ...future.startTime, 
[15:32:49.941]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:49.941]             version = "1.8"), class = "FutureResult")
[15:32:49.941]     }, finally = {
[15:32:49.941]         if (!identical(...future.workdir, getwd())) 
[15:32:49.941]             setwd(...future.workdir)
[15:32:49.941]         {
[15:32:49.941]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:49.941]                 ...future.oldOptions$nwarnings <- NULL
[15:32:49.941]             }
[15:32:49.941]             base::options(...future.oldOptions)
[15:32:49.941]             if (.Platform$OS.type == "windows") {
[15:32:49.941]                 old_names <- names(...future.oldEnvVars)
[15:32:49.941]                 envs <- base::Sys.getenv()
[15:32:49.941]                 names <- names(envs)
[15:32:49.941]                 common <- intersect(names, old_names)
[15:32:49.941]                 added <- setdiff(names, old_names)
[15:32:49.941]                 removed <- setdiff(old_names, names)
[15:32:49.941]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:49.941]                   envs[common]]
[15:32:49.941]                 NAMES <- toupper(changed)
[15:32:49.941]                 args <- list()
[15:32:49.941]                 for (kk in seq_along(NAMES)) {
[15:32:49.941]                   name <- changed[[kk]]
[15:32:49.941]                   NAME <- NAMES[[kk]]
[15:32:49.941]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.941]                     next
[15:32:49.941]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.941]                 }
[15:32:49.941]                 NAMES <- toupper(added)
[15:32:49.941]                 for (kk in seq_along(NAMES)) {
[15:32:49.941]                   name <- added[[kk]]
[15:32:49.941]                   NAME <- NAMES[[kk]]
[15:32:49.941]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.941]                     next
[15:32:49.941]                   args[[name]] <- ""
[15:32:49.941]                 }
[15:32:49.941]                 NAMES <- toupper(removed)
[15:32:49.941]                 for (kk in seq_along(NAMES)) {
[15:32:49.941]                   name <- removed[[kk]]
[15:32:49.941]                   NAME <- NAMES[[kk]]
[15:32:49.941]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:49.941]                     next
[15:32:49.941]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:49.941]                 }
[15:32:49.941]                 if (length(args) > 0) 
[15:32:49.941]                   base::do.call(base::Sys.setenv, args = args)
[15:32:49.941]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:49.941]             }
[15:32:49.941]             else {
[15:32:49.941]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:49.941]             }
[15:32:49.941]             {
[15:32:49.941]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:49.941]                   0L) {
[15:32:49.941]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:49.941]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:49.941]                   base::options(opts)
[15:32:49.941]                 }
[15:32:49.941]                 {
[15:32:49.941]                   {
[15:32:49.941]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:49.941]                     NULL
[15:32:49.941]                   }
[15:32:49.941]                   options(future.plan = NULL)
[15:32:49.941]                   if (is.na(NA_character_)) 
[15:32:49.941]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:49.941]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:49.941]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:49.941]                     .init = FALSE)
[15:32:49.941]                 }
[15:32:49.941]             }
[15:32:49.941]         }
[15:32:49.941]     })
[15:32:49.941]     if (TRUE) {
[15:32:49.941]         base::sink(type = "output", split = FALSE)
[15:32:49.941]         if (TRUE) {
[15:32:49.941]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:49.941]         }
[15:32:49.941]         else {
[15:32:49.941]             ...future.result["stdout"] <- base::list(NULL)
[15:32:49.941]         }
[15:32:49.941]         base::close(...future.stdout)
[15:32:49.941]         ...future.stdout <- NULL
[15:32:49.941]     }
[15:32:49.941]     ...future.result$conditions <- ...future.conditions
[15:32:49.941]     ...future.result$finished <- base::Sys.time()
[15:32:49.941]     ...future.result
[15:32:49.941] }
[15:32:49.950] Exporting 5 global objects (4.16 KiB) to cluster node #1 ...
[15:32:49.951] Exporting '...future.FUN' (4.07 KiB) to cluster node #1 ...
[15:32:49.952] Exporting '...future.FUN' (4.07 KiB) to cluster node #1 ... DONE
[15:32:49.952] Exporting 'future.call.arguments' (96 bytes) to cluster node #1 ...
[15:32:49.953] Exporting 'future.call.arguments' (96 bytes) to cluster node #1 ... DONE
[15:32:49.954] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:49.955] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:49.955] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:49.956] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:49.956] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:49.957] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:49.958] Exporting 5 global objects (4.16 KiB) to cluster node #1 ... DONE
[15:32:49.959] MultisessionFuture started
[15:32:49.959] - Launch lazy future ... done
[15:32:49.959] run() for 'MultisessionFuture' ... done
[15:32:49.960] Created future:
[15:32:49.983] receiveMessageFromWorker() for ClusterFuture ...
[15:32:49.984] - Validating connection of MultisessionFuture
[15:32:49.985] - received message: FutureResult
[15:32:49.985] - Received FutureResult
[15:32:49.985] - Erased future from FutureRegistry
[15:32:49.986] result() for ClusterFuture ...
[15:32:49.986] - result already collected: FutureResult
[15:32:49.986] result() for ClusterFuture ... done
[15:32:49.987] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:49.960] MultisessionFuture:
[15:32:49.960] Label: 'future_sapply-1'
[15:32:49.960] Expression:
[15:32:49.960] {
[15:32:49.960]     do.call(function(...) {
[15:32:49.960]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.960]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.960]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.960]             on.exit(options(oopts), add = TRUE)
[15:32:49.960]         }
[15:32:49.960]         {
[15:32:49.960]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.960]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.960]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.960]             })
[15:32:49.960]         }
[15:32:49.960]     }, args = future.call.arguments)
[15:32:49.960] }
[15:32:49.960] Lazy evaluation: FALSE
[15:32:49.960] Asynchronous evaluation: TRUE
[15:32:49.960] Local evaluation: TRUE
[15:32:49.960] Environment: R_GlobalEnv
[15:32:49.960] Capture standard output: TRUE
[15:32:49.960] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:49.960] Globals: 5 objects totaling 4.27 KiB (function '...future.FUN' of 4.07 KiB, DotDotDotList 'future.call.arguments' of 96 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:49.960] Packages: <none>
[15:32:49.960] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:49.960] Resolved: TRUE
[15:32:49.960] Value: <not collected>
[15:32:49.960] Conditions captured: <none>
[15:32:49.960] Early signaling: FALSE
[15:32:49.960] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:49.960] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:49.988] Chunk #1 of 2 ... DONE
[15:32:49.988] Chunk #2 of 2 ...
[15:32:49.988]  - Finding globals in 'X' for chunk #2 ...
[15:32:49.988] getGlobalsAndPackages() ...
[15:32:49.989] Searching for globals...
[15:32:49.989] 
[15:32:49.990] Searching for globals ... DONE
[15:32:49.990] - globals: [0] <none>
[15:32:49.990] getGlobalsAndPackages() ... DONE
[15:32:49.991]    + additional globals found: [n=0] 
[15:32:49.991]    + additional namespaces needed: [n=0] 
[15:32:49.991]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:49.992]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:49.992]  - seeds: <none>
[15:32:49.992]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.992] getGlobalsAndPackages() ...
[15:32:49.993] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.993] Resolving globals: FALSE
[15:32:49.993] Tweak future expression to call with '...' arguments ...
[15:32:49.994] {
[15:32:49.994]     do.call(function(...) {
[15:32:49.994]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:49.994]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:49.994]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:49.994]             on.exit(options(oopts), add = TRUE)
[15:32:49.994]         }
[15:32:49.994]         {
[15:32:49.994]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:49.994]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:49.994]                 ...future.FUN(...future.X_jj, ...)
[15:32:49.994]             })
[15:32:49.994]         }
[15:32:49.994]     }, args = future.call.arguments)
[15:32:49.994] }
[15:32:49.995] Tweak future expression to call with '...' arguments ... DONE
[15:32:49.995] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:49.996] 
[15:32:49.996] getGlobalsAndPackages() ... DONE
[15:32:49.997] run() for 'Future' ...
[15:32:49.997] - state: 'created'
[15:32:49.998] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:50.016] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.017] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:50.017]   - Field: 'node'
[15:32:50.018]   - Field: 'label'
[15:32:50.018]   - Field: 'local'
[15:32:50.018]   - Field: 'owner'
[15:32:50.019]   - Field: 'envir'
[15:32:50.019]   - Field: 'workers'
[15:32:50.019]   - Field: 'packages'
[15:32:50.020]   - Field: 'gc'
[15:32:50.020]   - Field: 'conditions'
[15:32:50.020]   - Field: 'persistent'
[15:32:50.021]   - Field: 'expr'
[15:32:50.021]   - Field: 'uuid'
[15:32:50.021]   - Field: 'seed'
[15:32:50.021]   - Field: 'version'
[15:32:50.022]   - Field: 'result'
[15:32:50.022]   - Field: 'asynchronous'
[15:32:50.022]   - Field: 'calls'
[15:32:50.023]   - Field: 'globals'
[15:32:50.023]   - Field: 'stdout'
[15:32:50.023]   - Field: 'earlySignal'
[15:32:50.024]   - Field: 'lazy'
[15:32:50.024]   - Field: 'state'
[15:32:50.024] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:50.024] - Launch lazy future ...
[15:32:50.025] Packages needed by the future expression (n = 0): <none>
[15:32:50.025] Packages needed by future strategies (n = 0): <none>
[15:32:50.026] {
[15:32:50.026]     {
[15:32:50.026]         {
[15:32:50.026]             ...future.startTime <- base::Sys.time()
[15:32:50.026]             {
[15:32:50.026]                 {
[15:32:50.026]                   {
[15:32:50.026]                     {
[15:32:50.026]                       base::local({
[15:32:50.026]                         has_future <- base::requireNamespace("future", 
[15:32:50.026]                           quietly = TRUE)
[15:32:50.026]                         if (has_future) {
[15:32:50.026]                           ns <- base::getNamespace("future")
[15:32:50.026]                           version <- ns[[".package"]][["version"]]
[15:32:50.026]                           if (is.null(version)) 
[15:32:50.026]                             version <- utils::packageVersion("future")
[15:32:50.026]                         }
[15:32:50.026]                         else {
[15:32:50.026]                           version <- NULL
[15:32:50.026]                         }
[15:32:50.026]                         if (!has_future || version < "1.8.0") {
[15:32:50.026]                           info <- base::c(r_version = base::gsub("R version ", 
[15:32:50.026]                             "", base::R.version$version.string), 
[15:32:50.026]                             platform = base::sprintf("%s (%s-bit)", 
[15:32:50.026]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:32:50.026]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:50.026]                               "release", "version")], collapse = " "), 
[15:32:50.026]                             hostname = base::Sys.info()[["nodename"]])
[15:32:50.026]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:32:50.026]                             info)
[15:32:50.026]                           info <- base::paste(info, collapse = "; ")
[15:32:50.026]                           if (!has_future) {
[15:32:50.026]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:50.026]                               info)
[15:32:50.026]                           }
[15:32:50.026]                           else {
[15:32:50.026]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:50.026]                               info, version)
[15:32:50.026]                           }
[15:32:50.026]                           base::stop(msg)
[15:32:50.026]                         }
[15:32:50.026]                       })
[15:32:50.026]                     }
[15:32:50.026]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:50.026]                     base::options(mc.cores = 1L)
[15:32:50.026]                   }
[15:32:50.026]                   ...future.strategy.old <- future::plan("list")
[15:32:50.026]                   options(future.plan = NULL)
[15:32:50.026]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.026]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:50.026]                 }
[15:32:50.026]                 ...future.workdir <- getwd()
[15:32:50.026]             }
[15:32:50.026]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:50.026]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:50.026]         }
[15:32:50.026]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:50.026]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:50.026]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:50.026]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:50.026]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:50.026]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:50.026]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:50.026]             base::names(...future.oldOptions))
[15:32:50.026]     }
[15:32:50.026]     if (FALSE) {
[15:32:50.026]     }
[15:32:50.026]     else {
[15:32:50.026]         if (TRUE) {
[15:32:50.026]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:50.026]                 open = "w")
[15:32:50.026]         }
[15:32:50.026]         else {
[15:32:50.026]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:50.026]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:50.026]         }
[15:32:50.026]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:50.026]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:50.026]             base::sink(type = "output", split = FALSE)
[15:32:50.026]             base::close(...future.stdout)
[15:32:50.026]         }, add = TRUE)
[15:32:50.026]     }
[15:32:50.026]     ...future.frame <- base::sys.nframe()
[15:32:50.026]     ...future.conditions <- base::list()
[15:32:50.026]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:50.026]     if (FALSE) {
[15:32:50.026]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:50.026]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:50.026]     }
[15:32:50.026]     ...future.result <- base::tryCatch({
[15:32:50.026]         base::withCallingHandlers({
[15:32:50.026]             ...future.value <- base::withVisible(base::local({
[15:32:50.026]                 ...future.makeSendCondition <- base::local({
[15:32:50.026]                   sendCondition <- NULL
[15:32:50.026]                   function(frame = 1L) {
[15:32:50.026]                     if (is.function(sendCondition)) 
[15:32:50.026]                       return(sendCondition)
[15:32:50.026]                     ns <- getNamespace("parallel")
[15:32:50.026]                     if (exists("sendData", mode = "function", 
[15:32:50.026]                       envir = ns)) {
[15:32:50.026]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:50.026]                         envir = ns)
[15:32:50.026]                       envir <- sys.frame(frame)
[15:32:50.026]                       master <- NULL
[15:32:50.026]                       while (!identical(envir, .GlobalEnv) && 
[15:32:50.026]                         !identical(envir, emptyenv())) {
[15:32:50.026]                         if (exists("master", mode = "list", envir = envir, 
[15:32:50.026]                           inherits = FALSE)) {
[15:32:50.026]                           master <- get("master", mode = "list", 
[15:32:50.026]                             envir = envir, inherits = FALSE)
[15:32:50.026]                           if (inherits(master, c("SOCKnode", 
[15:32:50.026]                             "SOCK0node"))) {
[15:32:50.026]                             sendCondition <<- function(cond) {
[15:32:50.026]                               data <- list(type = "VALUE", value = cond, 
[15:32:50.026]                                 success = TRUE)
[15:32:50.026]                               parallel_sendData(master, data)
[15:32:50.026]                             }
[15:32:50.026]                             return(sendCondition)
[15:32:50.026]                           }
[15:32:50.026]                         }
[15:32:50.026]                         frame <- frame + 1L
[15:32:50.026]                         envir <- sys.frame(frame)
[15:32:50.026]                       }
[15:32:50.026]                     }
[15:32:50.026]                     sendCondition <<- function(cond) NULL
[15:32:50.026]                   }
[15:32:50.026]                 })
[15:32:50.026]                 withCallingHandlers({
[15:32:50.026]                   {
[15:32:50.026]                     do.call(function(...) {
[15:32:50.026]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.026]                       if (!identical(...future.globals.maxSize.org, 
[15:32:50.026]                         ...future.globals.maxSize)) {
[15:32:50.026]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.026]                         on.exit(options(oopts), add = TRUE)
[15:32:50.026]                       }
[15:32:50.026]                       {
[15:32:50.026]                         lapply(seq_along(...future.elements_ii), 
[15:32:50.026]                           FUN = function(jj) {
[15:32:50.026]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.026]                             ...future.FUN(...future.X_jj, ...)
[15:32:50.026]                           })
[15:32:50.026]                       }
[15:32:50.026]                     }, args = future.call.arguments)
[15:32:50.026]                   }
[15:32:50.026]                 }, immediateCondition = function(cond) {
[15:32:50.026]                   sendCondition <- ...future.makeSendCondition()
[15:32:50.026]                   sendCondition(cond)
[15:32:50.026]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.026]                   {
[15:32:50.026]                     inherits <- base::inherits
[15:32:50.026]                     invokeRestart <- base::invokeRestart
[15:32:50.026]                     is.null <- base::is.null
[15:32:50.026]                     muffled <- FALSE
[15:32:50.026]                     if (inherits(cond, "message")) {
[15:32:50.026]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:50.026]                       if (muffled) 
[15:32:50.026]                         invokeRestart("muffleMessage")
[15:32:50.026]                     }
[15:32:50.026]                     else if (inherits(cond, "warning")) {
[15:32:50.026]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:50.026]                       if (muffled) 
[15:32:50.026]                         invokeRestart("muffleWarning")
[15:32:50.026]                     }
[15:32:50.026]                     else if (inherits(cond, "condition")) {
[15:32:50.026]                       if (!is.null(pattern)) {
[15:32:50.026]                         computeRestarts <- base::computeRestarts
[15:32:50.026]                         grepl <- base::grepl
[15:32:50.026]                         restarts <- computeRestarts(cond)
[15:32:50.026]                         for (restart in restarts) {
[15:32:50.026]                           name <- restart$name
[15:32:50.026]                           if (is.null(name)) 
[15:32:50.026]                             next
[15:32:50.026]                           if (!grepl(pattern, name)) 
[15:32:50.026]                             next
[15:32:50.026]                           invokeRestart(restart)
[15:32:50.026]                           muffled <- TRUE
[15:32:50.026]                           break
[15:32:50.026]                         }
[15:32:50.026]                       }
[15:32:50.026]                     }
[15:32:50.026]                     invisible(muffled)
[15:32:50.026]                   }
[15:32:50.026]                   muffleCondition(cond)
[15:32:50.026]                 })
[15:32:50.026]             }))
[15:32:50.026]             future::FutureResult(value = ...future.value$value, 
[15:32:50.026]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.026]                   ...future.rng), globalenv = if (FALSE) 
[15:32:50.026]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:50.026]                     ...future.globalenv.names))
[15:32:50.026]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:50.026]         }, condition = base::local({
[15:32:50.026]             c <- base::c
[15:32:50.026]             inherits <- base::inherits
[15:32:50.026]             invokeRestart <- base::invokeRestart
[15:32:50.026]             length <- base::length
[15:32:50.026]             list <- base::list
[15:32:50.026]             seq.int <- base::seq.int
[15:32:50.026]             signalCondition <- base::signalCondition
[15:32:50.026]             sys.calls <- base::sys.calls
[15:32:50.026]             `[[` <- base::`[[`
[15:32:50.026]             `+` <- base::`+`
[15:32:50.026]             `<<-` <- base::`<<-`
[15:32:50.026]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:50.026]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:50.026]                   3L)]
[15:32:50.026]             }
[15:32:50.026]             function(cond) {
[15:32:50.026]                 is_error <- inherits(cond, "error")
[15:32:50.026]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:50.026]                   NULL)
[15:32:50.026]                 if (is_error) {
[15:32:50.026]                   sessionInformation <- function() {
[15:32:50.026]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:50.026]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:50.026]                       search = base::search(), system = base::Sys.info())
[15:32:50.026]                   }
[15:32:50.026]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.026]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:50.026]                     cond$call), session = sessionInformation(), 
[15:32:50.026]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:50.026]                   signalCondition(cond)
[15:32:50.026]                 }
[15:32:50.026]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:50.026]                 "immediateCondition"))) {
[15:32:50.026]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:50.026]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.026]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:50.026]                   if (TRUE && !signal) {
[15:32:50.026]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.026]                     {
[15:32:50.026]                       inherits <- base::inherits
[15:32:50.026]                       invokeRestart <- base::invokeRestart
[15:32:50.026]                       is.null <- base::is.null
[15:32:50.026]                       muffled <- FALSE
[15:32:50.026]                       if (inherits(cond, "message")) {
[15:32:50.026]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.026]                         if (muffled) 
[15:32:50.026]                           invokeRestart("muffleMessage")
[15:32:50.026]                       }
[15:32:50.026]                       else if (inherits(cond, "warning")) {
[15:32:50.026]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.026]                         if (muffled) 
[15:32:50.026]                           invokeRestart("muffleWarning")
[15:32:50.026]                       }
[15:32:50.026]                       else if (inherits(cond, "condition")) {
[15:32:50.026]                         if (!is.null(pattern)) {
[15:32:50.026]                           computeRestarts <- base::computeRestarts
[15:32:50.026]                           grepl <- base::grepl
[15:32:50.026]                           restarts <- computeRestarts(cond)
[15:32:50.026]                           for (restart in restarts) {
[15:32:50.026]                             name <- restart$name
[15:32:50.026]                             if (is.null(name)) 
[15:32:50.026]                               next
[15:32:50.026]                             if (!grepl(pattern, name)) 
[15:32:50.026]                               next
[15:32:50.026]                             invokeRestart(restart)
[15:32:50.026]                             muffled <- TRUE
[15:32:50.026]                             break
[15:32:50.026]                           }
[15:32:50.026]                         }
[15:32:50.026]                       }
[15:32:50.026]                       invisible(muffled)
[15:32:50.026]                     }
[15:32:50.026]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.026]                   }
[15:32:50.026]                 }
[15:32:50.026]                 else {
[15:32:50.026]                   if (TRUE) {
[15:32:50.026]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.026]                     {
[15:32:50.026]                       inherits <- base::inherits
[15:32:50.026]                       invokeRestart <- base::invokeRestart
[15:32:50.026]                       is.null <- base::is.null
[15:32:50.026]                       muffled <- FALSE
[15:32:50.026]                       if (inherits(cond, "message")) {
[15:32:50.026]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.026]                         if (muffled) 
[15:32:50.026]                           invokeRestart("muffleMessage")
[15:32:50.026]                       }
[15:32:50.026]                       else if (inherits(cond, "warning")) {
[15:32:50.026]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.026]                         if (muffled) 
[15:32:50.026]                           invokeRestart("muffleWarning")
[15:32:50.026]                       }
[15:32:50.026]                       else if (inherits(cond, "condition")) {
[15:32:50.026]                         if (!is.null(pattern)) {
[15:32:50.026]                           computeRestarts <- base::computeRestarts
[15:32:50.026]                           grepl <- base::grepl
[15:32:50.026]                           restarts <- computeRestarts(cond)
[15:32:50.026]                           for (restart in restarts) {
[15:32:50.026]                             name <- restart$name
[15:32:50.026]                             if (is.null(name)) 
[15:32:50.026]                               next
[15:32:50.026]                             if (!grepl(pattern, name)) 
[15:32:50.026]                               next
[15:32:50.026]                             invokeRestart(restart)
[15:32:50.026]                             muffled <- TRUE
[15:32:50.026]                             break
[15:32:50.026]                           }
[15:32:50.026]                         }
[15:32:50.026]                       }
[15:32:50.026]                       invisible(muffled)
[15:32:50.026]                     }
[15:32:50.026]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.026]                   }
[15:32:50.026]                 }
[15:32:50.026]             }
[15:32:50.026]         }))
[15:32:50.026]     }, error = function(ex) {
[15:32:50.026]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:50.026]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.026]                 ...future.rng), started = ...future.startTime, 
[15:32:50.026]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:50.026]             version = "1.8"), class = "FutureResult")
[15:32:50.026]     }, finally = {
[15:32:50.026]         if (!identical(...future.workdir, getwd())) 
[15:32:50.026]             setwd(...future.workdir)
[15:32:50.026]         {
[15:32:50.026]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:50.026]                 ...future.oldOptions$nwarnings <- NULL
[15:32:50.026]             }
[15:32:50.026]             base::options(...future.oldOptions)
[15:32:50.026]             if (.Platform$OS.type == "windows") {
[15:32:50.026]                 old_names <- names(...future.oldEnvVars)
[15:32:50.026]                 envs <- base::Sys.getenv()
[15:32:50.026]                 names <- names(envs)
[15:32:50.026]                 common <- intersect(names, old_names)
[15:32:50.026]                 added <- setdiff(names, old_names)
[15:32:50.026]                 removed <- setdiff(old_names, names)
[15:32:50.026]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:50.026]                   envs[common]]
[15:32:50.026]                 NAMES <- toupper(changed)
[15:32:50.026]                 args <- list()
[15:32:50.026]                 for (kk in seq_along(NAMES)) {
[15:32:50.026]                   name <- changed[[kk]]
[15:32:50.026]                   NAME <- NAMES[[kk]]
[15:32:50.026]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.026]                     next
[15:32:50.026]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.026]                 }
[15:32:50.026]                 NAMES <- toupper(added)
[15:32:50.026]                 for (kk in seq_along(NAMES)) {
[15:32:50.026]                   name <- added[[kk]]
[15:32:50.026]                   NAME <- NAMES[[kk]]
[15:32:50.026]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.026]                     next
[15:32:50.026]                   args[[name]] <- ""
[15:32:50.026]                 }
[15:32:50.026]                 NAMES <- toupper(removed)
[15:32:50.026]                 for (kk in seq_along(NAMES)) {
[15:32:50.026]                   name <- removed[[kk]]
[15:32:50.026]                   NAME <- NAMES[[kk]]
[15:32:50.026]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.026]                     next
[15:32:50.026]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.026]                 }
[15:32:50.026]                 if (length(args) > 0) 
[15:32:50.026]                   base::do.call(base::Sys.setenv, args = args)
[15:32:50.026]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:50.026]             }
[15:32:50.026]             else {
[15:32:50.026]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:50.026]             }
[15:32:50.026]             {
[15:32:50.026]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:50.026]                   0L) {
[15:32:50.026]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:50.026]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:50.026]                   base::options(opts)
[15:32:50.026]                 }
[15:32:50.026]                 {
[15:32:50.026]                   {
[15:32:50.026]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:50.026]                     NULL
[15:32:50.026]                   }
[15:32:50.026]                   options(future.plan = NULL)
[15:32:50.026]                   if (is.na(NA_character_)) 
[15:32:50.026]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.026]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:50.026]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:50.026]                     .init = FALSE)
[15:32:50.026]                 }
[15:32:50.026]             }
[15:32:50.026]         }
[15:32:50.026]     })
[15:32:50.026]     if (TRUE) {
[15:32:50.026]         base::sink(type = "output", split = FALSE)
[15:32:50.026]         if (TRUE) {
[15:32:50.026]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:50.026]         }
[15:32:50.026]         else {
[15:32:50.026]             ...future.result["stdout"] <- base::list(NULL)
[15:32:50.026]         }
[15:32:50.026]         base::close(...future.stdout)
[15:32:50.026]         ...future.stdout <- NULL
[15:32:50.026]     }
[15:32:50.026]     ...future.result$conditions <- ...future.conditions
[15:32:50.026]     ...future.result$finished <- base::Sys.time()
[15:32:50.026]     ...future.result
[15:32:50.026] }
[15:32:50.036] Exporting 5 global objects (4.16 KiB) to cluster node #1 ...
[15:32:50.036] Exporting '...future.FUN' (4.07 KiB) to cluster node #1 ...
[15:32:50.037] Exporting '...future.FUN' (4.07 KiB) to cluster node #1 ... DONE
[15:32:50.038] Exporting 'future.call.arguments' (96 bytes) to cluster node #1 ...
[15:32:50.039] Exporting 'future.call.arguments' (96 bytes) to cluster node #1 ... DONE
[15:32:50.039] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:50.040] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:50.040] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:50.041] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:50.041] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:50.042] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:50.042] Exporting 5 global objects (4.16 KiB) to cluster node #1 ... DONE
[15:32:50.043] MultisessionFuture started
[15:32:50.043] - Launch lazy future ... done
[15:32:50.044] run() for 'MultisessionFuture' ... done
[15:32:50.044] Created future:
[15:32:50.119] receiveMessageFromWorker() for ClusterFuture ...
[15:32:50.119] - Validating connection of MultisessionFuture
[15:32:50.120] - received message: FutureResult
[15:32:50.120] - Received FutureResult
[15:32:50.121] - Erased future from FutureRegistry
[15:32:50.121] result() for ClusterFuture ...
[15:32:50.121] - result already collected: FutureResult
[15:32:50.122] result() for ClusterFuture ... done
[15:32:50.122] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:50.045] MultisessionFuture:
[15:32:50.045] Label: 'future_sapply-2'
[15:32:50.045] Expression:
[15:32:50.045] {
[15:32:50.045]     do.call(function(...) {
[15:32:50.045]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.045]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.045]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.045]             on.exit(options(oopts), add = TRUE)
[15:32:50.045]         }
[15:32:50.045]         {
[15:32:50.045]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.045]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.045]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.045]             })
[15:32:50.045]         }
[15:32:50.045]     }, args = future.call.arguments)
[15:32:50.045] }
[15:32:50.045] Lazy evaluation: FALSE
[15:32:50.045] Asynchronous evaluation: TRUE
[15:32:50.045] Local evaluation: TRUE
[15:32:50.045] Environment: R_GlobalEnv
[15:32:50.045] Capture standard output: TRUE
[15:32:50.045] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:50.045] Globals: 5 objects totaling 4.27 KiB (function '...future.FUN' of 4.07 KiB, DotDotDotList 'future.call.arguments' of 96 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:32:50.045] Packages: <none>
[15:32:50.045] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:50.045] Resolved: TRUE
[15:32:50.045] Value: <not collected>
[15:32:50.045] Conditions captured: <none>
[15:32:50.045] Early signaling: FALSE
[15:32:50.045] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:50.045] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.123] Chunk #2 of 2 ... DONE
[15:32:50.123] Launching 2 futures (chunks) ... DONE
[15:32:50.123] Resolving 2 futures (chunks) ...
[15:32:50.124] resolve() on list ...
[15:32:50.124]  recursive: 0
[15:32:50.124]  length: 2
[15:32:50.124] 
[15:32:50.125] Future #1
[15:32:50.125] result() for ClusterFuture ...
[15:32:50.125] - result already collected: FutureResult
[15:32:50.125] result() for ClusterFuture ... done
[15:32:50.125] result() for ClusterFuture ...
[15:32:50.126] - result already collected: FutureResult
[15:32:50.126] result() for ClusterFuture ... done
[15:32:50.126] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:50.126] - nx: 2
[15:32:50.126] - relay: TRUE
[15:32:50.126] - stdout: TRUE
[15:32:50.127] - signal: TRUE
[15:32:50.127] - resignal: FALSE
[15:32:50.127] - force: TRUE
[15:32:50.127] - relayed: [n=2] FALSE, FALSE
[15:32:50.127] - queued futures: [n=2] FALSE, FALSE
[15:32:50.127]  - until=1
[15:32:50.128]  - relaying element #1
[15:32:50.128] result() for ClusterFuture ...
[15:32:50.128] - result already collected: FutureResult
[15:32:50.128] result() for ClusterFuture ... done
[15:32:50.128] result() for ClusterFuture ...
[15:32:50.128] - result already collected: FutureResult
[15:32:50.129] result() for ClusterFuture ... done
[15:32:50.129] result() for ClusterFuture ...
[15:32:50.129] - result already collected: FutureResult
[15:32:50.129] result() for ClusterFuture ... done
[15:32:50.129] result() for ClusterFuture ...
[15:32:50.129] - result already collected: FutureResult
[15:32:50.130] result() for ClusterFuture ... done
[15:32:50.130] - relayed: [n=2] TRUE, FALSE
[15:32:50.130] - queued futures: [n=2] TRUE, FALSE
[15:32:50.130] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:50.130]  length: 1 (resolved future 1)
[15:32:50.130] Future #2
[15:32:50.131] result() for ClusterFuture ...
[15:32:50.131] - result already collected: FutureResult
[15:32:50.131] result() for ClusterFuture ... done
[15:32:50.131] result() for ClusterFuture ...
[15:32:50.131] - result already collected: FutureResult
[15:32:50.131] result() for ClusterFuture ... done
[15:32:50.132] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:50.132] - nx: 2
[15:32:50.132] - relay: TRUE
[15:32:50.132] - stdout: TRUE
[15:32:50.132] - signal: TRUE
[15:32:50.132] - resignal: FALSE
[15:32:50.133] - force: TRUE
[15:32:50.133] - relayed: [n=2] TRUE, FALSE
[15:32:50.133] - queued futures: [n=2] TRUE, FALSE
[15:32:50.133]  - until=2
[15:32:50.133]  - relaying element #2
[15:32:50.133] result() for ClusterFuture ...
[15:32:50.134] - result already collected: FutureResult
[15:32:50.134] result() for ClusterFuture ... done
[15:32:50.134] result() for ClusterFuture ...
[15:32:50.134] - result already collected: FutureResult
[15:32:50.134] result() for ClusterFuture ... done
[15:32:50.135] result() for ClusterFuture ...
[15:32:50.135] - result already collected: FutureResult
[15:32:50.135] result() for ClusterFuture ... done
[15:32:50.135] result() for ClusterFuture ...
[15:32:50.135] - result already collected: FutureResult
[15:32:50.135] result() for ClusterFuture ... done
[15:32:50.135] - relayed: [n=2] TRUE, TRUE
[15:32:50.136] - queued futures: [n=2] TRUE, TRUE
[15:32:50.136] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:50.136]  length: 0 (resolved future 2)
[15:32:50.136] Relaying remaining futures
[15:32:50.136] signalConditionsASAP(NULL, pos=0) ...
[15:32:50.136] - nx: 2
[15:32:50.137] - relay: TRUE
[15:32:50.137] - stdout: TRUE
[15:32:50.137] - signal: TRUE
[15:32:50.137] - resignal: FALSE
[15:32:50.137] - force: TRUE
[15:32:50.137] - relayed: [n=2] TRUE, TRUE
[15:32:50.137] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:50.138] - relayed: [n=2] TRUE, TRUE
[15:32:50.138] - queued futures: [n=2] TRUE, TRUE
[15:32:50.138] signalConditionsASAP(NULL, pos=0) ... done
[15:32:50.138] resolve() on list ... DONE
[15:32:50.138] result() for ClusterFuture ...
[15:32:50.139] - result already collected: FutureResult
[15:32:50.139] result() for ClusterFuture ... done
[15:32:50.139] result() for ClusterFuture ...
[15:32:50.139] - result already collected: FutureResult
[15:32:50.139] result() for ClusterFuture ... done
[15:32:50.139] result() for ClusterFuture ...
[15:32:50.140] - result already collected: FutureResult
[15:32:50.140] result() for ClusterFuture ... done
[15:32:50.140] result() for ClusterFuture ...
[15:32:50.140] - result already collected: FutureResult
[15:32:50.140] result() for ClusterFuture ... done
[15:32:50.140]  - Number of value chunks collected: 2
[15:32:50.141] Resolving 2 futures (chunks) ... DONE
[15:32:50.141] Reducing values from 2 chunks ...
[15:32:50.141]  - Number of values collected after concatenation: 4
[15:32:50.141]  - Number of values expected: 4
[15:32:50.141] Reducing values from 2 chunks ... DONE
[15:32:50.141] future_lapply() ... DONE
[15:32:50.142] future_lapply() ...
[15:32:50.147] Number of chunks: 2
[15:32:50.148] getGlobalsAndPackagesXApply() ...
[15:32:50.148]  - future.globals: TRUE
[15:32:50.148] getGlobalsAndPackages() ...
[15:32:50.148] Searching for globals...
[15:32:50.153] - globals found: [18] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types', 'outer', 'rep'
[15:32:50.153] Searching for globals ... DONE
[15:32:50.153] Resolving globals: FALSE
[15:32:50.155] The total size of the 7 globals is 96.20 KiB (98504 bytes)
[15:32:50.155] The total size of the 7 globals exported for future expression ('FUN(y = c(2, 4, 6, 8, 10))') is 96.20 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:50.155] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:50.156] - packages: [1] 'future.apply'
[15:32:50.156] getGlobalsAndPackages() ... DONE
[15:32:50.156]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:50.156]  - needed namespaces: [n=1] 'future.apply'
[15:32:50.157] Finding globals ... DONE
[15:32:50.157]  - use_args: TRUE
[15:32:50.157]  - Getting '...' globals ...
[15:32:50.157] resolve() on list ...
[15:32:50.158]  recursive: 0
[15:32:50.158]  length: 1
[15:32:50.158]  elements: '...'
[15:32:50.158]  length: 0 (resolved future 1)
[15:32:50.158] resolve() on list ... DONE
[15:32:50.159]    - '...' content: [n=1] 'y'
[15:32:50.159] List of 1
[15:32:50.159]  $ ...:List of 1
[15:32:50.159]   ..$ y: num [1:5] 2 4 6 8 10
[15:32:50.159]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:50.159]  - attr(*, "where")=List of 1
[15:32:50.159]   ..$ ...:<environment: 0x0000022d41a57be0> 
[15:32:50.159]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:50.159]  - attr(*, "resolved")= logi TRUE
[15:32:50.159]  - attr(*, "total_size")= num NA
[15:32:50.162]  - Getting '...' globals ... DONE
[15:32:50.165] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:50.165] List of 8
[15:32:50.165]  $ ...future.FUN:function (x, ...)  
[15:32:50.165]  $ x_FUN        :function (x, y)  
[15:32:50.165]  $ times        : int 15
[15:32:50.165]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:50.165]  $ stop_if_not  :function (...)  
[15:32:50.165]  $ dim          : int [1:2] 3 5
[15:32:50.165]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:50.165]  $ ...          :List of 1
[15:32:50.165]   ..$ y: num [1:5] 2 4 6 8 10
[15:32:50.165]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:50.165]  - attr(*, "where")=List of 8
[15:32:50.165]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:50.165]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:50.165]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:50.165]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:50.165]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:50.165]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:50.165]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:50.165]   ..$ ...          :<environment: 0x0000022d41a57be0> 
[15:32:50.165]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:50.165]  - attr(*, "resolved")= logi FALSE
[15:32:50.165]  - attr(*, "total_size")= num 98600
[15:32:50.173] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:50.174] getGlobalsAndPackagesXApply() ... DONE
[15:32:50.174] Number of futures (= number of chunks): 2
[15:32:50.175] Launching 2 futures (chunks) ...
[15:32:50.175] Chunk #1 of 2 ...
[15:32:50.175]  - Finding globals in 'X' for chunk #1 ...
[15:32:50.175] getGlobalsAndPackages() ...
[15:32:50.176] Searching for globals...
[15:32:50.176] 
[15:32:50.177] Searching for globals ... DONE
[15:32:50.177] - globals: [0] <none>
[15:32:50.177] getGlobalsAndPackages() ... DONE
[15:32:50.177]    + additional globals found: [n=0] 
[15:32:50.178]    + additional namespaces needed: [n=0] 
[15:32:50.178]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:50.178]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:50.178]  - seeds: <none>
[15:32:50.179]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.179] getGlobalsAndPackages() ...
[15:32:50.179] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.180] Resolving globals: FALSE
[15:32:50.180] Tweak future expression to call with '...' arguments ...
[15:32:50.180] {
[15:32:50.180]     do.call(function(...) {
[15:32:50.180]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.180]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.180]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.180]             on.exit(options(oopts), add = TRUE)
[15:32:50.180]         }
[15:32:50.180]         {
[15:32:50.180]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.180]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.180]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.180]             })
[15:32:50.180]         }
[15:32:50.180]     }, args = future.call.arguments)
[15:32:50.180] }
[15:32:50.181] Tweak future expression to call with '...' arguments ... DONE
[15:32:50.182] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.183] - packages: [1] 'future.apply'
[15:32:50.183] getGlobalsAndPackages() ... DONE
[15:32:50.183] run() for 'Future' ...
[15:32:50.184] - state: 'created'
[15:32:50.184] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:50.204] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.205] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:50.205]   - Field: 'node'
[15:32:50.206]   - Field: 'label'
[15:32:50.206]   - Field: 'local'
[15:32:50.206]   - Field: 'owner'
[15:32:50.207]   - Field: 'envir'
[15:32:50.207]   - Field: 'workers'
[15:32:50.207]   - Field: 'packages'
[15:32:50.207]   - Field: 'gc'
[15:32:50.208]   - Field: 'conditions'
[15:32:50.208]   - Field: 'persistent'
[15:32:50.208]   - Field: 'expr'
[15:32:50.209]   - Field: 'uuid'
[15:32:50.209]   - Field: 'seed'
[15:32:50.209]   - Field: 'version'
[15:32:50.210]   - Field: 'result'
[15:32:50.210]   - Field: 'asynchronous'
[15:32:50.210]   - Field: 'calls'
[15:32:50.211]   - Field: 'globals'
[15:32:50.211]   - Field: 'stdout'
[15:32:50.211]   - Field: 'earlySignal'
[15:32:50.212]   - Field: 'lazy'
[15:32:50.212]   - Field: 'state'
[15:32:50.212] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:50.212] - Launch lazy future ...
[15:32:50.213] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:50.213] Packages needed by future strategies (n = 0): <none>
[15:32:50.215] {
[15:32:50.215]     {
[15:32:50.215]         {
[15:32:50.215]             ...future.startTime <- base::Sys.time()
[15:32:50.215]             {
[15:32:50.215]                 {
[15:32:50.215]                   {
[15:32:50.215]                     {
[15:32:50.215]                       {
[15:32:50.215]                         base::local({
[15:32:50.215]                           has_future <- base::requireNamespace("future", 
[15:32:50.215]                             quietly = TRUE)
[15:32:50.215]                           if (has_future) {
[15:32:50.215]                             ns <- base::getNamespace("future")
[15:32:50.215]                             version <- ns[[".package"]][["version"]]
[15:32:50.215]                             if (is.null(version)) 
[15:32:50.215]                               version <- utils::packageVersion("future")
[15:32:50.215]                           }
[15:32:50.215]                           else {
[15:32:50.215]                             version <- NULL
[15:32:50.215]                           }
[15:32:50.215]                           if (!has_future || version < "1.8.0") {
[15:32:50.215]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:50.215]                               "", base::R.version$version.string), 
[15:32:50.215]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:50.215]                                 base::R.version$platform, 8 * 
[15:32:50.215]                                   base::.Machine$sizeof.pointer), 
[15:32:50.215]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:50.215]                                 "release", "version")], collapse = " "), 
[15:32:50.215]                               hostname = base::Sys.info()[["nodename"]])
[15:32:50.215]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:50.215]                               info)
[15:32:50.215]                             info <- base::paste(info, collapse = "; ")
[15:32:50.215]                             if (!has_future) {
[15:32:50.215]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:50.215]                                 info)
[15:32:50.215]                             }
[15:32:50.215]                             else {
[15:32:50.215]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:50.215]                                 info, version)
[15:32:50.215]                             }
[15:32:50.215]                             base::stop(msg)
[15:32:50.215]                           }
[15:32:50.215]                         })
[15:32:50.215]                       }
[15:32:50.215]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:50.215]                       base::options(mc.cores = 1L)
[15:32:50.215]                     }
[15:32:50.215]                     base::local({
[15:32:50.215]                       for (pkg in "future.apply") {
[15:32:50.215]                         base::loadNamespace(pkg)
[15:32:50.215]                         base::library(pkg, character.only = TRUE)
[15:32:50.215]                       }
[15:32:50.215]                     })
[15:32:50.215]                   }
[15:32:50.215]                   ...future.strategy.old <- future::plan("list")
[15:32:50.215]                   options(future.plan = NULL)
[15:32:50.215]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.215]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:50.215]                 }
[15:32:50.215]                 ...future.workdir <- getwd()
[15:32:50.215]             }
[15:32:50.215]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:50.215]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:50.215]         }
[15:32:50.215]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:50.215]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:50.215]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:50.215]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:50.215]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:50.215]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:50.215]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:50.215]             base::names(...future.oldOptions))
[15:32:50.215]     }
[15:32:50.215]     if (FALSE) {
[15:32:50.215]     }
[15:32:50.215]     else {
[15:32:50.215]         if (TRUE) {
[15:32:50.215]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:50.215]                 open = "w")
[15:32:50.215]         }
[15:32:50.215]         else {
[15:32:50.215]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:50.215]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:50.215]         }
[15:32:50.215]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:50.215]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:50.215]             base::sink(type = "output", split = FALSE)
[15:32:50.215]             base::close(...future.stdout)
[15:32:50.215]         }, add = TRUE)
[15:32:50.215]     }
[15:32:50.215]     ...future.frame <- base::sys.nframe()
[15:32:50.215]     ...future.conditions <- base::list()
[15:32:50.215]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:50.215]     if (FALSE) {
[15:32:50.215]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:50.215]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:50.215]     }
[15:32:50.215]     ...future.result <- base::tryCatch({
[15:32:50.215]         base::withCallingHandlers({
[15:32:50.215]             ...future.value <- base::withVisible(base::local({
[15:32:50.215]                 ...future.makeSendCondition <- base::local({
[15:32:50.215]                   sendCondition <- NULL
[15:32:50.215]                   function(frame = 1L) {
[15:32:50.215]                     if (is.function(sendCondition)) 
[15:32:50.215]                       return(sendCondition)
[15:32:50.215]                     ns <- getNamespace("parallel")
[15:32:50.215]                     if (exists("sendData", mode = "function", 
[15:32:50.215]                       envir = ns)) {
[15:32:50.215]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:50.215]                         envir = ns)
[15:32:50.215]                       envir <- sys.frame(frame)
[15:32:50.215]                       master <- NULL
[15:32:50.215]                       while (!identical(envir, .GlobalEnv) && 
[15:32:50.215]                         !identical(envir, emptyenv())) {
[15:32:50.215]                         if (exists("master", mode = "list", envir = envir, 
[15:32:50.215]                           inherits = FALSE)) {
[15:32:50.215]                           master <- get("master", mode = "list", 
[15:32:50.215]                             envir = envir, inherits = FALSE)
[15:32:50.215]                           if (inherits(master, c("SOCKnode", 
[15:32:50.215]                             "SOCK0node"))) {
[15:32:50.215]                             sendCondition <<- function(cond) {
[15:32:50.215]                               data <- list(type = "VALUE", value = cond, 
[15:32:50.215]                                 success = TRUE)
[15:32:50.215]                               parallel_sendData(master, data)
[15:32:50.215]                             }
[15:32:50.215]                             return(sendCondition)
[15:32:50.215]                           }
[15:32:50.215]                         }
[15:32:50.215]                         frame <- frame + 1L
[15:32:50.215]                         envir <- sys.frame(frame)
[15:32:50.215]                       }
[15:32:50.215]                     }
[15:32:50.215]                     sendCondition <<- function(cond) NULL
[15:32:50.215]                   }
[15:32:50.215]                 })
[15:32:50.215]                 withCallingHandlers({
[15:32:50.215]                   {
[15:32:50.215]                     do.call(function(...) {
[15:32:50.215]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.215]                       if (!identical(...future.globals.maxSize.org, 
[15:32:50.215]                         ...future.globals.maxSize)) {
[15:32:50.215]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.215]                         on.exit(options(oopts), add = TRUE)
[15:32:50.215]                       }
[15:32:50.215]                       {
[15:32:50.215]                         lapply(seq_along(...future.elements_ii), 
[15:32:50.215]                           FUN = function(jj) {
[15:32:50.215]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.215]                             ...future.FUN(...future.X_jj, ...)
[15:32:50.215]                           })
[15:32:50.215]                       }
[15:32:50.215]                     }, args = future.call.arguments)
[15:32:50.215]                   }
[15:32:50.215]                 }, immediateCondition = function(cond) {
[15:32:50.215]                   sendCondition <- ...future.makeSendCondition()
[15:32:50.215]                   sendCondition(cond)
[15:32:50.215]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.215]                   {
[15:32:50.215]                     inherits <- base::inherits
[15:32:50.215]                     invokeRestart <- base::invokeRestart
[15:32:50.215]                     is.null <- base::is.null
[15:32:50.215]                     muffled <- FALSE
[15:32:50.215]                     if (inherits(cond, "message")) {
[15:32:50.215]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:50.215]                       if (muffled) 
[15:32:50.215]                         invokeRestart("muffleMessage")
[15:32:50.215]                     }
[15:32:50.215]                     else if (inherits(cond, "warning")) {
[15:32:50.215]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:50.215]                       if (muffled) 
[15:32:50.215]                         invokeRestart("muffleWarning")
[15:32:50.215]                     }
[15:32:50.215]                     else if (inherits(cond, "condition")) {
[15:32:50.215]                       if (!is.null(pattern)) {
[15:32:50.215]                         computeRestarts <- base::computeRestarts
[15:32:50.215]                         grepl <- base::grepl
[15:32:50.215]                         restarts <- computeRestarts(cond)
[15:32:50.215]                         for (restart in restarts) {
[15:32:50.215]                           name <- restart$name
[15:32:50.215]                           if (is.null(name)) 
[15:32:50.215]                             next
[15:32:50.215]                           if (!grepl(pattern, name)) 
[15:32:50.215]                             next
[15:32:50.215]                           invokeRestart(restart)
[15:32:50.215]                           muffled <- TRUE
[15:32:50.215]                           break
[15:32:50.215]                         }
[15:32:50.215]                       }
[15:32:50.215]                     }
[15:32:50.215]                     invisible(muffled)
[15:32:50.215]                   }
[15:32:50.215]                   muffleCondition(cond)
[15:32:50.215]                 })
[15:32:50.215]             }))
[15:32:50.215]             future::FutureResult(value = ...future.value$value, 
[15:32:50.215]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.215]                   ...future.rng), globalenv = if (FALSE) 
[15:32:50.215]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:50.215]                     ...future.globalenv.names))
[15:32:50.215]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:50.215]         }, condition = base::local({
[15:32:50.215]             c <- base::c
[15:32:50.215]             inherits <- base::inherits
[15:32:50.215]             invokeRestart <- base::invokeRestart
[15:32:50.215]             length <- base::length
[15:32:50.215]             list <- base::list
[15:32:50.215]             seq.int <- base::seq.int
[15:32:50.215]             signalCondition <- base::signalCondition
[15:32:50.215]             sys.calls <- base::sys.calls
[15:32:50.215]             `[[` <- base::`[[`
[15:32:50.215]             `+` <- base::`+`
[15:32:50.215]             `<<-` <- base::`<<-`
[15:32:50.215]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:50.215]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:50.215]                   3L)]
[15:32:50.215]             }
[15:32:50.215]             function(cond) {
[15:32:50.215]                 is_error <- inherits(cond, "error")
[15:32:50.215]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:50.215]                   NULL)
[15:32:50.215]                 if (is_error) {
[15:32:50.215]                   sessionInformation <- function() {
[15:32:50.215]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:50.215]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:50.215]                       search = base::search(), system = base::Sys.info())
[15:32:50.215]                   }
[15:32:50.215]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.215]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:50.215]                     cond$call), session = sessionInformation(), 
[15:32:50.215]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:50.215]                   signalCondition(cond)
[15:32:50.215]                 }
[15:32:50.215]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:50.215]                 "immediateCondition"))) {
[15:32:50.215]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:50.215]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.215]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:50.215]                   if (TRUE && !signal) {
[15:32:50.215]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.215]                     {
[15:32:50.215]                       inherits <- base::inherits
[15:32:50.215]                       invokeRestart <- base::invokeRestart
[15:32:50.215]                       is.null <- base::is.null
[15:32:50.215]                       muffled <- FALSE
[15:32:50.215]                       if (inherits(cond, "message")) {
[15:32:50.215]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.215]                         if (muffled) 
[15:32:50.215]                           invokeRestart("muffleMessage")
[15:32:50.215]                       }
[15:32:50.215]                       else if (inherits(cond, "warning")) {
[15:32:50.215]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.215]                         if (muffled) 
[15:32:50.215]                           invokeRestart("muffleWarning")
[15:32:50.215]                       }
[15:32:50.215]                       else if (inherits(cond, "condition")) {
[15:32:50.215]                         if (!is.null(pattern)) {
[15:32:50.215]                           computeRestarts <- base::computeRestarts
[15:32:50.215]                           grepl <- base::grepl
[15:32:50.215]                           restarts <- computeRestarts(cond)
[15:32:50.215]                           for (restart in restarts) {
[15:32:50.215]                             name <- restart$name
[15:32:50.215]                             if (is.null(name)) 
[15:32:50.215]                               next
[15:32:50.215]                             if (!grepl(pattern, name)) 
[15:32:50.215]                               next
[15:32:50.215]                             invokeRestart(restart)
[15:32:50.215]                             muffled <- TRUE
[15:32:50.215]                             break
[15:32:50.215]                           }
[15:32:50.215]                         }
[15:32:50.215]                       }
[15:32:50.215]                       invisible(muffled)
[15:32:50.215]                     }
[15:32:50.215]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.215]                   }
[15:32:50.215]                 }
[15:32:50.215]                 else {
[15:32:50.215]                   if (TRUE) {
[15:32:50.215]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.215]                     {
[15:32:50.215]                       inherits <- base::inherits
[15:32:50.215]                       invokeRestart <- base::invokeRestart
[15:32:50.215]                       is.null <- base::is.null
[15:32:50.215]                       muffled <- FALSE
[15:32:50.215]                       if (inherits(cond, "message")) {
[15:32:50.215]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.215]                         if (muffled) 
[15:32:50.215]                           invokeRestart("muffleMessage")
[15:32:50.215]                       }
[15:32:50.215]                       else if (inherits(cond, "warning")) {
[15:32:50.215]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.215]                         if (muffled) 
[15:32:50.215]                           invokeRestart("muffleWarning")
[15:32:50.215]                       }
[15:32:50.215]                       else if (inherits(cond, "condition")) {
[15:32:50.215]                         if (!is.null(pattern)) {
[15:32:50.215]                           computeRestarts <- base::computeRestarts
[15:32:50.215]                           grepl <- base::grepl
[15:32:50.215]                           restarts <- computeRestarts(cond)
[15:32:50.215]                           for (restart in restarts) {
[15:32:50.215]                             name <- restart$name
[15:32:50.215]                             if (is.null(name)) 
[15:32:50.215]                               next
[15:32:50.215]                             if (!grepl(pattern, name)) 
[15:32:50.215]                               next
[15:32:50.215]                             invokeRestart(restart)
[15:32:50.215]                             muffled <- TRUE
[15:32:50.215]                             break
[15:32:50.215]                           }
[15:32:50.215]                         }
[15:32:50.215]                       }
[15:32:50.215]                       invisible(muffled)
[15:32:50.215]                     }
[15:32:50.215]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.215]                   }
[15:32:50.215]                 }
[15:32:50.215]             }
[15:32:50.215]         }))
[15:32:50.215]     }, error = function(ex) {
[15:32:50.215]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:50.215]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.215]                 ...future.rng), started = ...future.startTime, 
[15:32:50.215]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:50.215]             version = "1.8"), class = "FutureResult")
[15:32:50.215]     }, finally = {
[15:32:50.215]         if (!identical(...future.workdir, getwd())) 
[15:32:50.215]             setwd(...future.workdir)
[15:32:50.215]         {
[15:32:50.215]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:50.215]                 ...future.oldOptions$nwarnings <- NULL
[15:32:50.215]             }
[15:32:50.215]             base::options(...future.oldOptions)
[15:32:50.215]             if (.Platform$OS.type == "windows") {
[15:32:50.215]                 old_names <- names(...future.oldEnvVars)
[15:32:50.215]                 envs <- base::Sys.getenv()
[15:32:50.215]                 names <- names(envs)
[15:32:50.215]                 common <- intersect(names, old_names)
[15:32:50.215]                 added <- setdiff(names, old_names)
[15:32:50.215]                 removed <- setdiff(old_names, names)
[15:32:50.215]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:50.215]                   envs[common]]
[15:32:50.215]                 NAMES <- toupper(changed)
[15:32:50.215]                 args <- list()
[15:32:50.215]                 for (kk in seq_along(NAMES)) {
[15:32:50.215]                   name <- changed[[kk]]
[15:32:50.215]                   NAME <- NAMES[[kk]]
[15:32:50.215]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.215]                     next
[15:32:50.215]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.215]                 }
[15:32:50.215]                 NAMES <- toupper(added)
[15:32:50.215]                 for (kk in seq_along(NAMES)) {
[15:32:50.215]                   name <- added[[kk]]
[15:32:50.215]                   NAME <- NAMES[[kk]]
[15:32:50.215]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.215]                     next
[15:32:50.215]                   args[[name]] <- ""
[15:32:50.215]                 }
[15:32:50.215]                 NAMES <- toupper(removed)
[15:32:50.215]                 for (kk in seq_along(NAMES)) {
[15:32:50.215]                   name <- removed[[kk]]
[15:32:50.215]                   NAME <- NAMES[[kk]]
[15:32:50.215]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.215]                     next
[15:32:50.215]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.215]                 }
[15:32:50.215]                 if (length(args) > 0) 
[15:32:50.215]                   base::do.call(base::Sys.setenv, args = args)
[15:32:50.215]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:50.215]             }
[15:32:50.215]             else {
[15:32:50.215]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:50.215]             }
[15:32:50.215]             {
[15:32:50.215]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:50.215]                   0L) {
[15:32:50.215]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:50.215]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:50.215]                   base::options(opts)
[15:32:50.215]                 }
[15:32:50.215]                 {
[15:32:50.215]                   {
[15:32:50.215]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:50.215]                     NULL
[15:32:50.215]                   }
[15:32:50.215]                   options(future.plan = NULL)
[15:32:50.215]                   if (is.na(NA_character_)) 
[15:32:50.215]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.215]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:50.215]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:50.215]                     .init = FALSE)
[15:32:50.215]                 }
[15:32:50.215]             }
[15:32:50.215]         }
[15:32:50.215]     })
[15:32:50.215]     if (TRUE) {
[15:32:50.215]         base::sink(type = "output", split = FALSE)
[15:32:50.215]         if (TRUE) {
[15:32:50.215]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:50.215]         }
[15:32:50.215]         else {
[15:32:50.215]             ...future.result["stdout"] <- base::list(NULL)
[15:32:50.215]         }
[15:32:50.215]         base::close(...future.stdout)
[15:32:50.215]         ...future.stdout <- NULL
[15:32:50.215]     }
[15:32:50.215]     ...future.result$conditions <- ...future.conditions
[15:32:50.215]     ...future.result$finished <- base::Sys.time()
[15:32:50.215]     ...future.result
[15:32:50.215] }
[15:32:50.224] Exporting 11 global objects (96.29 KiB) to cluster node #1 ...
[15:32:50.224] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:50.225] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:50.225] Exporting 'x_FUN' (4.07 KiB) to cluster node #1 ...
[15:32:50.226] Exporting 'x_FUN' (4.07 KiB) to cluster node #1 ... DONE
[15:32:50.226] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:50.227] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:50.228] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:50.228] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:50.229] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:50.230] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:50.230] Exporting 'dim' (56 bytes) to cluster node #1 ...
[15:32:50.230] Exporting 'dim' (56 bytes) to cluster node #1 ... DONE
[15:32:50.231] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:50.231] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:50.232] Exporting 'future.call.arguments' (96 bytes) to cluster node #1 ...
[15:32:50.232] Exporting 'future.call.arguments' (96 bytes) to cluster node #1 ... DONE
[15:32:50.233] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:50.233] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:50.234] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:50.234] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:50.235] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:50.235] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:50.236] Exporting 11 global objects (96.29 KiB) to cluster node #1 ... DONE
[15:32:50.237] MultisessionFuture started
[15:32:50.237] - Launch lazy future ... done
[15:32:50.237] run() for 'MultisessionFuture' ... done
[15:32:50.237] Created future:
[15:32:50.261] receiveMessageFromWorker() for ClusterFuture ...
[15:32:50.262] - Validating connection of MultisessionFuture
[15:32:50.262] - received message: FutureResult
[15:32:50.262] - Received FutureResult
[15:32:50.263] - Erased future from FutureRegistry
[15:32:50.263] result() for ClusterFuture ...
[15:32:50.263] - result already collected: FutureResult
[15:32:50.264] result() for ClusterFuture ... done
[15:32:50.264] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:50.238] MultisessionFuture:
[15:32:50.238] Label: 'future_vapply-1'
[15:32:50.238] Expression:
[15:32:50.238] {
[15:32:50.238]     do.call(function(...) {
[15:32:50.238]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.238]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.238]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.238]             on.exit(options(oopts), add = TRUE)
[15:32:50.238]         }
[15:32:50.238]         {
[15:32:50.238]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.238]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.238]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.238]             })
[15:32:50.238]         }
[15:32:50.238]     }, args = future.call.arguments)
[15:32:50.238] }
[15:32:50.238] Lazy evaluation: FALSE
[15:32:50.238] Asynchronous evaluation: TRUE
[15:32:50.238] Local evaluation: TRUE
[15:32:50.238] Environment: R_GlobalEnv
[15:32:50.238] Capture standard output: TRUE
[15:32:50.238] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:50.238] Globals: 11 objects totaling 96.40 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 4.07 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:50.238] Packages: 1 packages ('future.apply')
[15:32:50.238] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:50.238] Resolved: TRUE
[15:32:50.238] Value: <not collected>
[15:32:50.238] Conditions captured: <none>
[15:32:50.238] Early signaling: FALSE
[15:32:50.238] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:50.238] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.265] Chunk #1 of 2 ... DONE
[15:32:50.265] Chunk #2 of 2 ...
[15:32:50.265]  - Finding globals in 'X' for chunk #2 ...
[15:32:50.265] getGlobalsAndPackages() ...
[15:32:50.266] Searching for globals...
[15:32:50.266] 
[15:32:50.267] Searching for globals ... DONE
[15:32:50.267] - globals: [0] <none>
[15:32:50.267] getGlobalsAndPackages() ... DONE
[15:32:50.267]    + additional globals found: [n=0] 
[15:32:50.268]    + additional namespaces needed: [n=0] 
[15:32:50.268]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:50.268]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:50.268]  - seeds: <none>
[15:32:50.269]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.269] getGlobalsAndPackages() ...
[15:32:50.269] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.270] Resolving globals: FALSE
[15:32:50.270] Tweak future expression to call with '...' arguments ...
[15:32:50.270] {
[15:32:50.270]     do.call(function(...) {
[15:32:50.270]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.270]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.270]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.270]             on.exit(options(oopts), add = TRUE)
[15:32:50.270]         }
[15:32:50.270]         {
[15:32:50.270]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.270]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.270]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.270]             })
[15:32:50.270]         }
[15:32:50.270]     }, args = future.call.arguments)
[15:32:50.270] }
[15:32:50.271] Tweak future expression to call with '...' arguments ... DONE
[15:32:50.272] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.272] - packages: [1] 'future.apply'
[15:32:50.273] getGlobalsAndPackages() ... DONE
[15:32:50.273] run() for 'Future' ...
[15:32:50.274] - state: 'created'
[15:32:50.274] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:50.291] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.292] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:50.292]   - Field: 'node'
[15:32:50.293]   - Field: 'label'
[15:32:50.293]   - Field: 'local'
[15:32:50.293]   - Field: 'owner'
[15:32:50.293]   - Field: 'envir'
[15:32:50.294]   - Field: 'workers'
[15:32:50.294]   - Field: 'packages'
[15:32:50.294]   - Field: 'gc'
[15:32:50.295]   - Field: 'conditions'
[15:32:50.295]   - Field: 'persistent'
[15:32:50.295]   - Field: 'expr'
[15:32:50.295]   - Field: 'uuid'
[15:32:50.296]   - Field: 'seed'
[15:32:50.296]   - Field: 'version'
[15:32:50.296]   - Field: 'result'
[15:32:50.297]   - Field: 'asynchronous'
[15:32:50.297]   - Field: 'calls'
[15:32:50.297]   - Field: 'globals'
[15:32:50.297]   - Field: 'stdout'
[15:32:50.298]   - Field: 'earlySignal'
[15:32:50.298]   - Field: 'lazy'
[15:32:50.298]   - Field: 'state'
[15:32:50.299] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:50.299] - Launch lazy future ...
[15:32:50.300] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:50.300] Packages needed by future strategies (n = 0): <none>
[15:32:50.301] {
[15:32:50.301]     {
[15:32:50.301]         {
[15:32:50.301]             ...future.startTime <- base::Sys.time()
[15:32:50.301]             {
[15:32:50.301]                 {
[15:32:50.301]                   {
[15:32:50.301]                     {
[15:32:50.301]                       {
[15:32:50.301]                         base::local({
[15:32:50.301]                           has_future <- base::requireNamespace("future", 
[15:32:50.301]                             quietly = TRUE)
[15:32:50.301]                           if (has_future) {
[15:32:50.301]                             ns <- base::getNamespace("future")
[15:32:50.301]                             version <- ns[[".package"]][["version"]]
[15:32:50.301]                             if (is.null(version)) 
[15:32:50.301]                               version <- utils::packageVersion("future")
[15:32:50.301]                           }
[15:32:50.301]                           else {
[15:32:50.301]                             version <- NULL
[15:32:50.301]                           }
[15:32:50.301]                           if (!has_future || version < "1.8.0") {
[15:32:50.301]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:50.301]                               "", base::R.version$version.string), 
[15:32:50.301]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:50.301]                                 base::R.version$platform, 8 * 
[15:32:50.301]                                   base::.Machine$sizeof.pointer), 
[15:32:50.301]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:50.301]                                 "release", "version")], collapse = " "), 
[15:32:50.301]                               hostname = base::Sys.info()[["nodename"]])
[15:32:50.301]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:50.301]                               info)
[15:32:50.301]                             info <- base::paste(info, collapse = "; ")
[15:32:50.301]                             if (!has_future) {
[15:32:50.301]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:50.301]                                 info)
[15:32:50.301]                             }
[15:32:50.301]                             else {
[15:32:50.301]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:50.301]                                 info, version)
[15:32:50.301]                             }
[15:32:50.301]                             base::stop(msg)
[15:32:50.301]                           }
[15:32:50.301]                         })
[15:32:50.301]                       }
[15:32:50.301]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:50.301]                       base::options(mc.cores = 1L)
[15:32:50.301]                     }
[15:32:50.301]                     base::local({
[15:32:50.301]                       for (pkg in "future.apply") {
[15:32:50.301]                         base::loadNamespace(pkg)
[15:32:50.301]                         base::library(pkg, character.only = TRUE)
[15:32:50.301]                       }
[15:32:50.301]                     })
[15:32:50.301]                   }
[15:32:50.301]                   ...future.strategy.old <- future::plan("list")
[15:32:50.301]                   options(future.plan = NULL)
[15:32:50.301]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.301]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:50.301]                 }
[15:32:50.301]                 ...future.workdir <- getwd()
[15:32:50.301]             }
[15:32:50.301]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:50.301]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:50.301]         }
[15:32:50.301]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:50.301]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:50.301]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:50.301]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:50.301]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:50.301]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:50.301]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:50.301]             base::names(...future.oldOptions))
[15:32:50.301]     }
[15:32:50.301]     if (FALSE) {
[15:32:50.301]     }
[15:32:50.301]     else {
[15:32:50.301]         if (TRUE) {
[15:32:50.301]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:50.301]                 open = "w")
[15:32:50.301]         }
[15:32:50.301]         else {
[15:32:50.301]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:50.301]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:50.301]         }
[15:32:50.301]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:50.301]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:50.301]             base::sink(type = "output", split = FALSE)
[15:32:50.301]             base::close(...future.stdout)
[15:32:50.301]         }, add = TRUE)
[15:32:50.301]     }
[15:32:50.301]     ...future.frame <- base::sys.nframe()
[15:32:50.301]     ...future.conditions <- base::list()
[15:32:50.301]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:50.301]     if (FALSE) {
[15:32:50.301]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:50.301]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:50.301]     }
[15:32:50.301]     ...future.result <- base::tryCatch({
[15:32:50.301]         base::withCallingHandlers({
[15:32:50.301]             ...future.value <- base::withVisible(base::local({
[15:32:50.301]                 ...future.makeSendCondition <- base::local({
[15:32:50.301]                   sendCondition <- NULL
[15:32:50.301]                   function(frame = 1L) {
[15:32:50.301]                     if (is.function(sendCondition)) 
[15:32:50.301]                       return(sendCondition)
[15:32:50.301]                     ns <- getNamespace("parallel")
[15:32:50.301]                     if (exists("sendData", mode = "function", 
[15:32:50.301]                       envir = ns)) {
[15:32:50.301]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:50.301]                         envir = ns)
[15:32:50.301]                       envir <- sys.frame(frame)
[15:32:50.301]                       master <- NULL
[15:32:50.301]                       while (!identical(envir, .GlobalEnv) && 
[15:32:50.301]                         !identical(envir, emptyenv())) {
[15:32:50.301]                         if (exists("master", mode = "list", envir = envir, 
[15:32:50.301]                           inherits = FALSE)) {
[15:32:50.301]                           master <- get("master", mode = "list", 
[15:32:50.301]                             envir = envir, inherits = FALSE)
[15:32:50.301]                           if (inherits(master, c("SOCKnode", 
[15:32:50.301]                             "SOCK0node"))) {
[15:32:50.301]                             sendCondition <<- function(cond) {
[15:32:50.301]                               data <- list(type = "VALUE", value = cond, 
[15:32:50.301]                                 success = TRUE)
[15:32:50.301]                               parallel_sendData(master, data)
[15:32:50.301]                             }
[15:32:50.301]                             return(sendCondition)
[15:32:50.301]                           }
[15:32:50.301]                         }
[15:32:50.301]                         frame <- frame + 1L
[15:32:50.301]                         envir <- sys.frame(frame)
[15:32:50.301]                       }
[15:32:50.301]                     }
[15:32:50.301]                     sendCondition <<- function(cond) NULL
[15:32:50.301]                   }
[15:32:50.301]                 })
[15:32:50.301]                 withCallingHandlers({
[15:32:50.301]                   {
[15:32:50.301]                     do.call(function(...) {
[15:32:50.301]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.301]                       if (!identical(...future.globals.maxSize.org, 
[15:32:50.301]                         ...future.globals.maxSize)) {
[15:32:50.301]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.301]                         on.exit(options(oopts), add = TRUE)
[15:32:50.301]                       }
[15:32:50.301]                       {
[15:32:50.301]                         lapply(seq_along(...future.elements_ii), 
[15:32:50.301]                           FUN = function(jj) {
[15:32:50.301]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.301]                             ...future.FUN(...future.X_jj, ...)
[15:32:50.301]                           })
[15:32:50.301]                       }
[15:32:50.301]                     }, args = future.call.arguments)
[15:32:50.301]                   }
[15:32:50.301]                 }, immediateCondition = function(cond) {
[15:32:50.301]                   sendCondition <- ...future.makeSendCondition()
[15:32:50.301]                   sendCondition(cond)
[15:32:50.301]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.301]                   {
[15:32:50.301]                     inherits <- base::inherits
[15:32:50.301]                     invokeRestart <- base::invokeRestart
[15:32:50.301]                     is.null <- base::is.null
[15:32:50.301]                     muffled <- FALSE
[15:32:50.301]                     if (inherits(cond, "message")) {
[15:32:50.301]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:50.301]                       if (muffled) 
[15:32:50.301]                         invokeRestart("muffleMessage")
[15:32:50.301]                     }
[15:32:50.301]                     else if (inherits(cond, "warning")) {
[15:32:50.301]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:50.301]                       if (muffled) 
[15:32:50.301]                         invokeRestart("muffleWarning")
[15:32:50.301]                     }
[15:32:50.301]                     else if (inherits(cond, "condition")) {
[15:32:50.301]                       if (!is.null(pattern)) {
[15:32:50.301]                         computeRestarts <- base::computeRestarts
[15:32:50.301]                         grepl <- base::grepl
[15:32:50.301]                         restarts <- computeRestarts(cond)
[15:32:50.301]                         for (restart in restarts) {
[15:32:50.301]                           name <- restart$name
[15:32:50.301]                           if (is.null(name)) 
[15:32:50.301]                             next
[15:32:50.301]                           if (!grepl(pattern, name)) 
[15:32:50.301]                             next
[15:32:50.301]                           invokeRestart(restart)
[15:32:50.301]                           muffled <- TRUE
[15:32:50.301]                           break
[15:32:50.301]                         }
[15:32:50.301]                       }
[15:32:50.301]                     }
[15:32:50.301]                     invisible(muffled)
[15:32:50.301]                   }
[15:32:50.301]                   muffleCondition(cond)
[15:32:50.301]                 })
[15:32:50.301]             }))
[15:32:50.301]             future::FutureResult(value = ...future.value$value, 
[15:32:50.301]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.301]                   ...future.rng), globalenv = if (FALSE) 
[15:32:50.301]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:50.301]                     ...future.globalenv.names))
[15:32:50.301]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:50.301]         }, condition = base::local({
[15:32:50.301]             c <- base::c
[15:32:50.301]             inherits <- base::inherits
[15:32:50.301]             invokeRestart <- base::invokeRestart
[15:32:50.301]             length <- base::length
[15:32:50.301]             list <- base::list
[15:32:50.301]             seq.int <- base::seq.int
[15:32:50.301]             signalCondition <- base::signalCondition
[15:32:50.301]             sys.calls <- base::sys.calls
[15:32:50.301]             `[[` <- base::`[[`
[15:32:50.301]             `+` <- base::`+`
[15:32:50.301]             `<<-` <- base::`<<-`
[15:32:50.301]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:50.301]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:50.301]                   3L)]
[15:32:50.301]             }
[15:32:50.301]             function(cond) {
[15:32:50.301]                 is_error <- inherits(cond, "error")
[15:32:50.301]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:50.301]                   NULL)
[15:32:50.301]                 if (is_error) {
[15:32:50.301]                   sessionInformation <- function() {
[15:32:50.301]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:50.301]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:50.301]                       search = base::search(), system = base::Sys.info())
[15:32:50.301]                   }
[15:32:50.301]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.301]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:50.301]                     cond$call), session = sessionInformation(), 
[15:32:50.301]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:50.301]                   signalCondition(cond)
[15:32:50.301]                 }
[15:32:50.301]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:50.301]                 "immediateCondition"))) {
[15:32:50.301]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:50.301]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.301]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:50.301]                   if (TRUE && !signal) {
[15:32:50.301]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.301]                     {
[15:32:50.301]                       inherits <- base::inherits
[15:32:50.301]                       invokeRestart <- base::invokeRestart
[15:32:50.301]                       is.null <- base::is.null
[15:32:50.301]                       muffled <- FALSE
[15:32:50.301]                       if (inherits(cond, "message")) {
[15:32:50.301]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.301]                         if (muffled) 
[15:32:50.301]                           invokeRestart("muffleMessage")
[15:32:50.301]                       }
[15:32:50.301]                       else if (inherits(cond, "warning")) {
[15:32:50.301]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.301]                         if (muffled) 
[15:32:50.301]                           invokeRestart("muffleWarning")
[15:32:50.301]                       }
[15:32:50.301]                       else if (inherits(cond, "condition")) {
[15:32:50.301]                         if (!is.null(pattern)) {
[15:32:50.301]                           computeRestarts <- base::computeRestarts
[15:32:50.301]                           grepl <- base::grepl
[15:32:50.301]                           restarts <- computeRestarts(cond)
[15:32:50.301]                           for (restart in restarts) {
[15:32:50.301]                             name <- restart$name
[15:32:50.301]                             if (is.null(name)) 
[15:32:50.301]                               next
[15:32:50.301]                             if (!grepl(pattern, name)) 
[15:32:50.301]                               next
[15:32:50.301]                             invokeRestart(restart)
[15:32:50.301]                             muffled <- TRUE
[15:32:50.301]                             break
[15:32:50.301]                           }
[15:32:50.301]                         }
[15:32:50.301]                       }
[15:32:50.301]                       invisible(muffled)
[15:32:50.301]                     }
[15:32:50.301]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.301]                   }
[15:32:50.301]                 }
[15:32:50.301]                 else {
[15:32:50.301]                   if (TRUE) {
[15:32:50.301]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.301]                     {
[15:32:50.301]                       inherits <- base::inherits
[15:32:50.301]                       invokeRestart <- base::invokeRestart
[15:32:50.301]                       is.null <- base::is.null
[15:32:50.301]                       muffled <- FALSE
[15:32:50.301]                       if (inherits(cond, "message")) {
[15:32:50.301]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.301]                         if (muffled) 
[15:32:50.301]                           invokeRestart("muffleMessage")
[15:32:50.301]                       }
[15:32:50.301]                       else if (inherits(cond, "warning")) {
[15:32:50.301]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.301]                         if (muffled) 
[15:32:50.301]                           invokeRestart("muffleWarning")
[15:32:50.301]                       }
[15:32:50.301]                       else if (inherits(cond, "condition")) {
[15:32:50.301]                         if (!is.null(pattern)) {
[15:32:50.301]                           computeRestarts <- base::computeRestarts
[15:32:50.301]                           grepl <- base::grepl
[15:32:50.301]                           restarts <- computeRestarts(cond)
[15:32:50.301]                           for (restart in restarts) {
[15:32:50.301]                             name <- restart$name
[15:32:50.301]                             if (is.null(name)) 
[15:32:50.301]                               next
[15:32:50.301]                             if (!grepl(pattern, name)) 
[15:32:50.301]                               next
[15:32:50.301]                             invokeRestart(restart)
[15:32:50.301]                             muffled <- TRUE
[15:32:50.301]                             break
[15:32:50.301]                           }
[15:32:50.301]                         }
[15:32:50.301]                       }
[15:32:50.301]                       invisible(muffled)
[15:32:50.301]                     }
[15:32:50.301]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.301]                   }
[15:32:50.301]                 }
[15:32:50.301]             }
[15:32:50.301]         }))
[15:32:50.301]     }, error = function(ex) {
[15:32:50.301]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:50.301]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.301]                 ...future.rng), started = ...future.startTime, 
[15:32:50.301]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:50.301]             version = "1.8"), class = "FutureResult")
[15:32:50.301]     }, finally = {
[15:32:50.301]         if (!identical(...future.workdir, getwd())) 
[15:32:50.301]             setwd(...future.workdir)
[15:32:50.301]         {
[15:32:50.301]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:50.301]                 ...future.oldOptions$nwarnings <- NULL
[15:32:50.301]             }
[15:32:50.301]             base::options(...future.oldOptions)
[15:32:50.301]             if (.Platform$OS.type == "windows") {
[15:32:50.301]                 old_names <- names(...future.oldEnvVars)
[15:32:50.301]                 envs <- base::Sys.getenv()
[15:32:50.301]                 names <- names(envs)
[15:32:50.301]                 common <- intersect(names, old_names)
[15:32:50.301]                 added <- setdiff(names, old_names)
[15:32:50.301]                 removed <- setdiff(old_names, names)
[15:32:50.301]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:50.301]                   envs[common]]
[15:32:50.301]                 NAMES <- toupper(changed)
[15:32:50.301]                 args <- list()
[15:32:50.301]                 for (kk in seq_along(NAMES)) {
[15:32:50.301]                   name <- changed[[kk]]
[15:32:50.301]                   NAME <- NAMES[[kk]]
[15:32:50.301]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.301]                     next
[15:32:50.301]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.301]                 }
[15:32:50.301]                 NAMES <- toupper(added)
[15:32:50.301]                 for (kk in seq_along(NAMES)) {
[15:32:50.301]                   name <- added[[kk]]
[15:32:50.301]                   NAME <- NAMES[[kk]]
[15:32:50.301]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.301]                     next
[15:32:50.301]                   args[[name]] <- ""
[15:32:50.301]                 }
[15:32:50.301]                 NAMES <- toupper(removed)
[15:32:50.301]                 for (kk in seq_along(NAMES)) {
[15:32:50.301]                   name <- removed[[kk]]
[15:32:50.301]                   NAME <- NAMES[[kk]]
[15:32:50.301]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.301]                     next
[15:32:50.301]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.301]                 }
[15:32:50.301]                 if (length(args) > 0) 
[15:32:50.301]                   base::do.call(base::Sys.setenv, args = args)
[15:32:50.301]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:50.301]             }
[15:32:50.301]             else {
[15:32:50.301]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:50.301]             }
[15:32:50.301]             {
[15:32:50.301]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:50.301]                   0L) {
[15:32:50.301]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:50.301]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:50.301]                   base::options(opts)
[15:32:50.301]                 }
[15:32:50.301]                 {
[15:32:50.301]                   {
[15:32:50.301]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:50.301]                     NULL
[15:32:50.301]                   }
[15:32:50.301]                   options(future.plan = NULL)
[15:32:50.301]                   if (is.na(NA_character_)) 
[15:32:50.301]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.301]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:50.301]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:50.301]                     .init = FALSE)
[15:32:50.301]                 }
[15:32:50.301]             }
[15:32:50.301]         }
[15:32:50.301]     })
[15:32:50.301]     if (TRUE) {
[15:32:50.301]         base::sink(type = "output", split = FALSE)
[15:32:50.301]         if (TRUE) {
[15:32:50.301]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:50.301]         }
[15:32:50.301]         else {
[15:32:50.301]             ...future.result["stdout"] <- base::list(NULL)
[15:32:50.301]         }
[15:32:50.301]         base::close(...future.stdout)
[15:32:50.301]         ...future.stdout <- NULL
[15:32:50.301]     }
[15:32:50.301]     ...future.result$conditions <- ...future.conditions
[15:32:50.301]     ...future.result$finished <- base::Sys.time()
[15:32:50.301]     ...future.result
[15:32:50.301] }
[15:32:50.310] Exporting 11 global objects (96.29 KiB) to cluster node #1 ...
[15:32:50.310] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:50.311] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:50.311] Exporting 'x_FUN' (4.07 KiB) to cluster node #1 ...
[15:32:50.312] Exporting 'x_FUN' (4.07 KiB) to cluster node #1 ... DONE
[15:32:50.313] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:50.313] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:50.314] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:50.315] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:50.315] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:50.316] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:50.316] Exporting 'dim' (56 bytes) to cluster node #1 ...
[15:32:50.317] Exporting 'dim' (56 bytes) to cluster node #1 ... DONE
[15:32:50.317] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:50.318] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:50.319] Exporting 'future.call.arguments' (96 bytes) to cluster node #1 ...
[15:32:50.319] Exporting 'future.call.arguments' (96 bytes) to cluster node #1 ... DONE
[15:32:50.320] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:50.321] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:50.321] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:50.322] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:50.322] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:50.323] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:50.323] Exporting 11 global objects (96.29 KiB) to cluster node #1 ... DONE
[15:32:50.324] MultisessionFuture started
[15:32:50.324] - Launch lazy future ... done
[15:32:50.325] run() for 'MultisessionFuture' ... done
[15:32:50.325] Created future:
[15:32:50.356] receiveMessageFromWorker() for ClusterFuture ...
[15:32:50.356] - Validating connection of MultisessionFuture
[15:32:50.357] - received message: FutureResult
[15:32:50.357] - Received FutureResult
[15:32:50.357] - Erased future from FutureRegistry
[15:32:50.357] result() for ClusterFuture ...
[15:32:50.358] - result already collected: FutureResult
[15:32:50.358] result() for ClusterFuture ... done
[15:32:50.358] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:50.325] MultisessionFuture:
[15:32:50.325] Label: 'future_vapply-2'
[15:32:50.325] Expression:
[15:32:50.325] {
[15:32:50.325]     do.call(function(...) {
[15:32:50.325]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.325]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.325]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.325]             on.exit(options(oopts), add = TRUE)
[15:32:50.325]         }
[15:32:50.325]         {
[15:32:50.325]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.325]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.325]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.325]             })
[15:32:50.325]         }
[15:32:50.325]     }, args = future.call.arguments)
[15:32:50.325] }
[15:32:50.325] Lazy evaluation: FALSE
[15:32:50.325] Asynchronous evaluation: TRUE
[15:32:50.325] Local evaluation: TRUE
[15:32:50.325] Environment: R_GlobalEnv
[15:32:50.325] Capture standard output: TRUE
[15:32:50.325] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:50.325] Globals: 11 objects totaling 96.40 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 4.07 KiB, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:50.325] Packages: 1 packages ('future.apply')
[15:32:50.325] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:50.325] Resolved: TRUE
[15:32:50.325] Value: <not collected>
[15:32:50.325] Conditions captured: <none>
[15:32:50.325] Early signaling: FALSE
[15:32:50.325] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:50.325] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.359] Chunk #2 of 2 ... DONE
[15:32:50.359] Launching 2 futures (chunks) ... DONE
[15:32:50.359] Resolving 2 futures (chunks) ...
[15:32:50.360] resolve() on list ...
[15:32:50.360]  recursive: 0
[15:32:50.360]  length: 2
[15:32:50.361] 
[15:32:50.361] Future #1
[15:32:50.361] result() for ClusterFuture ...
[15:32:50.361] - result already collected: FutureResult
[15:32:50.362] result() for ClusterFuture ... done
[15:32:50.362] result() for ClusterFuture ...
[15:32:50.362] - result already collected: FutureResult
[15:32:50.362] result() for ClusterFuture ... done
[15:32:50.363] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:50.363] - nx: 2
[15:32:50.363] - relay: TRUE
[15:32:50.363] - stdout: TRUE
[15:32:50.363] - signal: TRUE
[15:32:50.364] - resignal: FALSE
[15:32:50.364] - force: TRUE
[15:32:50.364] - relayed: [n=2] FALSE, FALSE
[15:32:50.364] - queued futures: [n=2] FALSE, FALSE
[15:32:50.365]  - until=1
[15:32:50.365]  - relaying element #1
[15:32:50.365] result() for ClusterFuture ...
[15:32:50.365] - result already collected: FutureResult
[15:32:50.366] result() for ClusterFuture ... done
[15:32:50.366] result() for ClusterFuture ...
[15:32:50.366] - result already collected: FutureResult
[15:32:50.366] result() for ClusterFuture ... done
[15:32:50.367] result() for ClusterFuture ...
[15:32:50.367] - result already collected: FutureResult
[15:32:50.367] result() for ClusterFuture ... done
[15:32:50.367] result() for ClusterFuture ...
[15:32:50.368] - result already collected: FutureResult
[15:32:50.368] result() for ClusterFuture ... done
[15:32:50.368] - relayed: [n=2] TRUE, FALSE
[15:32:50.368] - queued futures: [n=2] TRUE, FALSE
[15:32:50.369] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:50.369]  length: 1 (resolved future 1)
[15:32:50.369] Future #2
[15:32:50.369] result() for ClusterFuture ...
[15:32:50.370] - result already collected: FutureResult
[15:32:50.370] result() for ClusterFuture ... done
[15:32:50.370] result() for ClusterFuture ...
[15:32:50.370] - result already collected: FutureResult
[15:32:50.371] result() for ClusterFuture ... done
[15:32:50.371] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:50.371] - nx: 2
[15:32:50.371] - relay: TRUE
[15:32:50.372] - stdout: TRUE
[15:32:50.372] - signal: TRUE
[15:32:50.372] - resignal: FALSE
[15:32:50.372] - force: TRUE
[15:32:50.373] - relayed: [n=2] TRUE, FALSE
[15:32:50.373] - queued futures: [n=2] TRUE, FALSE
[15:32:50.373]  - until=2
[15:32:50.373]  - relaying element #2
[15:32:50.374] result() for ClusterFuture ...
[15:32:50.374] - result already collected: FutureResult
[15:32:50.374] result() for ClusterFuture ... done
[15:32:50.375] result() for ClusterFuture ...
[15:32:50.375] - result already collected: FutureResult
[15:32:50.375] result() for ClusterFuture ... done
[15:32:50.375] result() for ClusterFuture ...
[15:32:50.376] - result already collected: FutureResult
[15:32:50.376] result() for ClusterFuture ... done
[15:32:50.376] result() for ClusterFuture ...
[15:32:50.376] - result already collected: FutureResult
[15:32:50.376] result() for ClusterFuture ... done
[15:32:50.377] - relayed: [n=2] TRUE, TRUE
[15:32:50.377] - queued futures: [n=2] TRUE, TRUE
[15:32:50.377] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:50.377]  length: 0 (resolved future 2)
[15:32:50.378] Relaying remaining futures
[15:32:50.378] signalConditionsASAP(NULL, pos=0) ...
[15:32:50.378] - nx: 2
[15:32:50.378] - relay: TRUE
[15:32:50.378] - stdout: TRUE
[15:32:50.379] - signal: TRUE
[15:32:50.379] - resignal: FALSE
[15:32:50.379] - force: TRUE
[15:32:50.379] - relayed: [n=2] TRUE, TRUE
[15:32:50.379] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:50.380] - relayed: [n=2] TRUE, TRUE
[15:32:50.380] - queued futures: [n=2] TRUE, TRUE
[15:32:50.380] signalConditionsASAP(NULL, pos=0) ... done
[15:32:50.381] resolve() on list ... DONE
[15:32:50.381] result() for ClusterFuture ...
[15:32:50.381] - result already collected: FutureResult
[15:32:50.381] result() for ClusterFuture ... done
[15:32:50.381] result() for ClusterFuture ...
[15:32:50.382] - result already collected: FutureResult
[15:32:50.382] result() for ClusterFuture ... done
[15:32:50.382] result() for ClusterFuture ...
[15:32:50.382] - result already collected: FutureResult
[15:32:50.383] result() for ClusterFuture ... done
[15:32:50.383] result() for ClusterFuture ...
[15:32:50.383] - result already collected: FutureResult
[15:32:50.383] result() for ClusterFuture ... done
[15:32:50.384]  - Number of value chunks collected: 2
[15:32:50.384] Resolving 2 futures (chunks) ... DONE
[15:32:50.384] Reducing values from 2 chunks ...
[15:32:50.384]  - Number of values collected after concatenation: 4
[15:32:50.384]  - Number of values expected: 4
[15:32:50.385] Reducing values from 2 chunks ... DONE
[15:32:50.385] future_lapply() ... DONE
 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"
[15:32:50.388] future_lapply() ...
[15:32:50.395] Number of chunks: 2
[15:32:50.395] getGlobalsAndPackagesXApply() ...
[15:32:50.395]  - future.globals: TRUE
[15:32:50.396] getGlobalsAndPackages() ...
[15:32:50.396] Searching for globals...
[15:32:50.402] - globals found: [16] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types'
[15:32:50.402] Searching for globals ... DONE
[15:32:50.402] Resolving globals: FALSE
[15:32:50.404] The total size of the 7 globals is 91.99 KiB (94200 bytes)
[15:32:50.405] The total size of the 7 globals exported for future expression ('FUN()') is 91.99 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:50.405] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:50.405] - packages: [1] 'future.apply'
[15:32:50.405] getGlobalsAndPackages() ... DONE
[15:32:50.406]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:50.406]  - needed namespaces: [n=1] 'future.apply'
[15:32:50.406] Finding globals ... DONE
[15:32:50.406]  - use_args: TRUE
[15:32:50.407]  - Getting '...' globals ...
[15:32:50.407] resolve() on list ...
[15:32:50.408]  recursive: 0
[15:32:50.408]  length: 1
[15:32:50.408]  elements: '...'
[15:32:50.408]  length: 0 (resolved future 1)
[15:32:50.408] resolve() on list ... DONE
[15:32:50.409]    - '...' content: [n=0] 
[15:32:50.409] List of 1
[15:32:50.409]  $ ...: list()
[15:32:50.409]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:50.409]  - attr(*, "where")=List of 1
[15:32:50.409]   ..$ ...:<environment: 0x0000022d416714c8> 
[15:32:50.409]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:50.409]  - attr(*, "resolved")= logi TRUE
[15:32:50.409]  - attr(*, "total_size")= num NA
[15:32:50.413]  - Getting '...' globals ... DONE
[15:32:50.414] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:50.414] List of 8
[15:32:50.414]  $ ...future.FUN:function (x, ...)  
[15:32:50.414]  $ x_FUN        :function (x)  
[15:32:50.414]  $ times        : int 1
[15:32:50.414]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:50.414]  $ stop_if_not  :function (...)  
[15:32:50.414]  $ dim          : NULL
[15:32:50.414]  $ valid_types  : chr "logical"
[15:32:50.414]  $ ...          : list()
[15:32:50.414]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:50.414]  - attr(*, "where")=List of 8
[15:32:50.414]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:50.414]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:50.414]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:50.414]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:50.414]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:50.414]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:50.414]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:50.414]   ..$ ...          :<environment: 0x0000022d416714c8> 
[15:32:50.414]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:50.414]  - attr(*, "resolved")= logi FALSE
[15:32:50.414]  - attr(*, "total_size")= num 94200
[15:32:50.424] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:50.424] getGlobalsAndPackagesXApply() ... DONE
[15:32:50.424] Number of futures (= number of chunks): 2
[15:32:50.425] Launching 2 futures (chunks) ...
[15:32:50.425] Chunk #1 of 2 ...
[15:32:50.425]  - Finding globals in 'X' for chunk #1 ...
[15:32:50.425] getGlobalsAndPackages() ...
[15:32:50.426] Searching for globals...
[15:32:50.430] 
[15:32:50.431] Searching for globals ... DONE
[15:32:50.431] - globals: [0] <none>
[15:32:50.431] getGlobalsAndPackages() ... DONE
[15:32:50.431]    + additional globals found: [n=0] 
[15:32:50.432]    + additional namespaces needed: [n=0] 
[15:32:50.432]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:50.432]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:50.432]  - seeds: <none>
[15:32:50.433]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.433] getGlobalsAndPackages() ...
[15:32:50.433] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.433] Resolving globals: FALSE
[15:32:50.434] Tweak future expression to call with '...' arguments ...
[15:32:50.434] {
[15:32:50.434]     do.call(function(...) {
[15:32:50.434]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.434]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.434]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.434]             on.exit(options(oopts), add = TRUE)
[15:32:50.434]         }
[15:32:50.434]         {
[15:32:50.434]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.434]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.434]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.434]             })
[15:32:50.434]         }
[15:32:50.434]     }, args = future.call.arguments)
[15:32:50.434] }
[15:32:50.435] Tweak future expression to call with '...' arguments ... DONE
[15:32:50.435] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.436] - packages: [1] 'future.apply'
[15:32:50.436] getGlobalsAndPackages() ... DONE
[15:32:50.436] run() for 'Future' ...
[15:32:50.436] - state: 'created'
[15:32:50.437] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:50.452] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.452] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:50.452]   - Field: 'node'
[15:32:50.452]   - Field: 'label'
[15:32:50.453]   - Field: 'local'
[15:32:50.453]   - Field: 'owner'
[15:32:50.453]   - Field: 'envir'
[15:32:50.454]   - Field: 'workers'
[15:32:50.454]   - Field: 'packages'
[15:32:50.454]   - Field: 'gc'
[15:32:50.455]   - Field: 'conditions'
[15:32:50.455]   - Field: 'persistent'
[15:32:50.455]   - Field: 'expr'
[15:32:50.455]   - Field: 'uuid'
[15:32:50.456]   - Field: 'seed'
[15:32:50.456]   - Field: 'version'
[15:32:50.456]   - Field: 'result'
[15:32:50.456]   - Field: 'asynchronous'
[15:32:50.457]   - Field: 'calls'
[15:32:50.457]   - Field: 'globals'
[15:32:50.457]   - Field: 'stdout'
[15:32:50.458]   - Field: 'earlySignal'
[15:32:50.458]   - Field: 'lazy'
[15:32:50.458]   - Field: 'state'
[15:32:50.459] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:50.459] - Launch lazy future ...
[15:32:50.459] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:50.460] Packages needed by future strategies (n = 0): <none>
[15:32:50.461] {
[15:32:50.461]     {
[15:32:50.461]         {
[15:32:50.461]             ...future.startTime <- base::Sys.time()
[15:32:50.461]             {
[15:32:50.461]                 {
[15:32:50.461]                   {
[15:32:50.461]                     {
[15:32:50.461]                       {
[15:32:50.461]                         base::local({
[15:32:50.461]                           has_future <- base::requireNamespace("future", 
[15:32:50.461]                             quietly = TRUE)
[15:32:50.461]                           if (has_future) {
[15:32:50.461]                             ns <- base::getNamespace("future")
[15:32:50.461]                             version <- ns[[".package"]][["version"]]
[15:32:50.461]                             if (is.null(version)) 
[15:32:50.461]                               version <- utils::packageVersion("future")
[15:32:50.461]                           }
[15:32:50.461]                           else {
[15:32:50.461]                             version <- NULL
[15:32:50.461]                           }
[15:32:50.461]                           if (!has_future || version < "1.8.0") {
[15:32:50.461]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:50.461]                               "", base::R.version$version.string), 
[15:32:50.461]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:50.461]                                 base::R.version$platform, 8 * 
[15:32:50.461]                                   base::.Machine$sizeof.pointer), 
[15:32:50.461]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:50.461]                                 "release", "version")], collapse = " "), 
[15:32:50.461]                               hostname = base::Sys.info()[["nodename"]])
[15:32:50.461]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:50.461]                               info)
[15:32:50.461]                             info <- base::paste(info, collapse = "; ")
[15:32:50.461]                             if (!has_future) {
[15:32:50.461]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:50.461]                                 info)
[15:32:50.461]                             }
[15:32:50.461]                             else {
[15:32:50.461]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:50.461]                                 info, version)
[15:32:50.461]                             }
[15:32:50.461]                             base::stop(msg)
[15:32:50.461]                           }
[15:32:50.461]                         })
[15:32:50.461]                       }
[15:32:50.461]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:50.461]                       base::options(mc.cores = 1L)
[15:32:50.461]                     }
[15:32:50.461]                     base::local({
[15:32:50.461]                       for (pkg in "future.apply") {
[15:32:50.461]                         base::loadNamespace(pkg)
[15:32:50.461]                         base::library(pkg, character.only = TRUE)
[15:32:50.461]                       }
[15:32:50.461]                     })
[15:32:50.461]                   }
[15:32:50.461]                   ...future.strategy.old <- future::plan("list")
[15:32:50.461]                   options(future.plan = NULL)
[15:32:50.461]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.461]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:50.461]                 }
[15:32:50.461]                 ...future.workdir <- getwd()
[15:32:50.461]             }
[15:32:50.461]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:50.461]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:50.461]         }
[15:32:50.461]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:50.461]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:50.461]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:50.461]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:50.461]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:50.461]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:50.461]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:50.461]             base::names(...future.oldOptions))
[15:32:50.461]     }
[15:32:50.461]     if (FALSE) {
[15:32:50.461]     }
[15:32:50.461]     else {
[15:32:50.461]         if (TRUE) {
[15:32:50.461]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:50.461]                 open = "w")
[15:32:50.461]         }
[15:32:50.461]         else {
[15:32:50.461]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:50.461]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:50.461]         }
[15:32:50.461]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:50.461]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:50.461]             base::sink(type = "output", split = FALSE)
[15:32:50.461]             base::close(...future.stdout)
[15:32:50.461]         }, add = TRUE)
[15:32:50.461]     }
[15:32:50.461]     ...future.frame <- base::sys.nframe()
[15:32:50.461]     ...future.conditions <- base::list()
[15:32:50.461]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:50.461]     if (FALSE) {
[15:32:50.461]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:50.461]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:50.461]     }
[15:32:50.461]     ...future.result <- base::tryCatch({
[15:32:50.461]         base::withCallingHandlers({
[15:32:50.461]             ...future.value <- base::withVisible(base::local({
[15:32:50.461]                 ...future.makeSendCondition <- base::local({
[15:32:50.461]                   sendCondition <- NULL
[15:32:50.461]                   function(frame = 1L) {
[15:32:50.461]                     if (is.function(sendCondition)) 
[15:32:50.461]                       return(sendCondition)
[15:32:50.461]                     ns <- getNamespace("parallel")
[15:32:50.461]                     if (exists("sendData", mode = "function", 
[15:32:50.461]                       envir = ns)) {
[15:32:50.461]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:50.461]                         envir = ns)
[15:32:50.461]                       envir <- sys.frame(frame)
[15:32:50.461]                       master <- NULL
[15:32:50.461]                       while (!identical(envir, .GlobalEnv) && 
[15:32:50.461]                         !identical(envir, emptyenv())) {
[15:32:50.461]                         if (exists("master", mode = "list", envir = envir, 
[15:32:50.461]                           inherits = FALSE)) {
[15:32:50.461]                           master <- get("master", mode = "list", 
[15:32:50.461]                             envir = envir, inherits = FALSE)
[15:32:50.461]                           if (inherits(master, c("SOCKnode", 
[15:32:50.461]                             "SOCK0node"))) {
[15:32:50.461]                             sendCondition <<- function(cond) {
[15:32:50.461]                               data <- list(type = "VALUE", value = cond, 
[15:32:50.461]                                 success = TRUE)
[15:32:50.461]                               parallel_sendData(master, data)
[15:32:50.461]                             }
[15:32:50.461]                             return(sendCondition)
[15:32:50.461]                           }
[15:32:50.461]                         }
[15:32:50.461]                         frame <- frame + 1L
[15:32:50.461]                         envir <- sys.frame(frame)
[15:32:50.461]                       }
[15:32:50.461]                     }
[15:32:50.461]                     sendCondition <<- function(cond) NULL
[15:32:50.461]                   }
[15:32:50.461]                 })
[15:32:50.461]                 withCallingHandlers({
[15:32:50.461]                   {
[15:32:50.461]                     do.call(function(...) {
[15:32:50.461]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.461]                       if (!identical(...future.globals.maxSize.org, 
[15:32:50.461]                         ...future.globals.maxSize)) {
[15:32:50.461]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.461]                         on.exit(options(oopts), add = TRUE)
[15:32:50.461]                       }
[15:32:50.461]                       {
[15:32:50.461]                         lapply(seq_along(...future.elements_ii), 
[15:32:50.461]                           FUN = function(jj) {
[15:32:50.461]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.461]                             ...future.FUN(...future.X_jj, ...)
[15:32:50.461]                           })
[15:32:50.461]                       }
[15:32:50.461]                     }, args = future.call.arguments)
[15:32:50.461]                   }
[15:32:50.461]                 }, immediateCondition = function(cond) {
[15:32:50.461]                   sendCondition <- ...future.makeSendCondition()
[15:32:50.461]                   sendCondition(cond)
[15:32:50.461]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.461]                   {
[15:32:50.461]                     inherits <- base::inherits
[15:32:50.461]                     invokeRestart <- base::invokeRestart
[15:32:50.461]                     is.null <- base::is.null
[15:32:50.461]                     muffled <- FALSE
[15:32:50.461]                     if (inherits(cond, "message")) {
[15:32:50.461]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:50.461]                       if (muffled) 
[15:32:50.461]                         invokeRestart("muffleMessage")
[15:32:50.461]                     }
[15:32:50.461]                     else if (inherits(cond, "warning")) {
[15:32:50.461]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:50.461]                       if (muffled) 
[15:32:50.461]                         invokeRestart("muffleWarning")
[15:32:50.461]                     }
[15:32:50.461]                     else if (inherits(cond, "condition")) {
[15:32:50.461]                       if (!is.null(pattern)) {
[15:32:50.461]                         computeRestarts <- base::computeRestarts
[15:32:50.461]                         grepl <- base::grepl
[15:32:50.461]                         restarts <- computeRestarts(cond)
[15:32:50.461]                         for (restart in restarts) {
[15:32:50.461]                           name <- restart$name
[15:32:50.461]                           if (is.null(name)) 
[15:32:50.461]                             next
[15:32:50.461]                           if (!grepl(pattern, name)) 
[15:32:50.461]                             next
[15:32:50.461]                           invokeRestart(restart)
[15:32:50.461]                           muffled <- TRUE
[15:32:50.461]                           break
[15:32:50.461]                         }
[15:32:50.461]                       }
[15:32:50.461]                     }
[15:32:50.461]                     invisible(muffled)
[15:32:50.461]                   }
[15:32:50.461]                   muffleCondition(cond)
[15:32:50.461]                 })
[15:32:50.461]             }))
[15:32:50.461]             future::FutureResult(value = ...future.value$value, 
[15:32:50.461]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.461]                   ...future.rng), globalenv = if (FALSE) 
[15:32:50.461]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:50.461]                     ...future.globalenv.names))
[15:32:50.461]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:50.461]         }, condition = base::local({
[15:32:50.461]             c <- base::c
[15:32:50.461]             inherits <- base::inherits
[15:32:50.461]             invokeRestart <- base::invokeRestart
[15:32:50.461]             length <- base::length
[15:32:50.461]             list <- base::list
[15:32:50.461]             seq.int <- base::seq.int
[15:32:50.461]             signalCondition <- base::signalCondition
[15:32:50.461]             sys.calls <- base::sys.calls
[15:32:50.461]             `[[` <- base::`[[`
[15:32:50.461]             `+` <- base::`+`
[15:32:50.461]             `<<-` <- base::`<<-`
[15:32:50.461]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:50.461]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:50.461]                   3L)]
[15:32:50.461]             }
[15:32:50.461]             function(cond) {
[15:32:50.461]                 is_error <- inherits(cond, "error")
[15:32:50.461]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:50.461]                   NULL)
[15:32:50.461]                 if (is_error) {
[15:32:50.461]                   sessionInformation <- function() {
[15:32:50.461]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:50.461]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:50.461]                       search = base::search(), system = base::Sys.info())
[15:32:50.461]                   }
[15:32:50.461]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.461]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:50.461]                     cond$call), session = sessionInformation(), 
[15:32:50.461]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:50.461]                   signalCondition(cond)
[15:32:50.461]                 }
[15:32:50.461]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:50.461]                 "immediateCondition"))) {
[15:32:50.461]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:50.461]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.461]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:50.461]                   if (TRUE && !signal) {
[15:32:50.461]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.461]                     {
[15:32:50.461]                       inherits <- base::inherits
[15:32:50.461]                       invokeRestart <- base::invokeRestart
[15:32:50.461]                       is.null <- base::is.null
[15:32:50.461]                       muffled <- FALSE
[15:32:50.461]                       if (inherits(cond, "message")) {
[15:32:50.461]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.461]                         if (muffled) 
[15:32:50.461]                           invokeRestart("muffleMessage")
[15:32:50.461]                       }
[15:32:50.461]                       else if (inherits(cond, "warning")) {
[15:32:50.461]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.461]                         if (muffled) 
[15:32:50.461]                           invokeRestart("muffleWarning")
[15:32:50.461]                       }
[15:32:50.461]                       else if (inherits(cond, "condition")) {
[15:32:50.461]                         if (!is.null(pattern)) {
[15:32:50.461]                           computeRestarts <- base::computeRestarts
[15:32:50.461]                           grepl <- base::grepl
[15:32:50.461]                           restarts <- computeRestarts(cond)
[15:32:50.461]                           for (restart in restarts) {
[15:32:50.461]                             name <- restart$name
[15:32:50.461]                             if (is.null(name)) 
[15:32:50.461]                               next
[15:32:50.461]                             if (!grepl(pattern, name)) 
[15:32:50.461]                               next
[15:32:50.461]                             invokeRestart(restart)
[15:32:50.461]                             muffled <- TRUE
[15:32:50.461]                             break
[15:32:50.461]                           }
[15:32:50.461]                         }
[15:32:50.461]                       }
[15:32:50.461]                       invisible(muffled)
[15:32:50.461]                     }
[15:32:50.461]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.461]                   }
[15:32:50.461]                 }
[15:32:50.461]                 else {
[15:32:50.461]                   if (TRUE) {
[15:32:50.461]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.461]                     {
[15:32:50.461]                       inherits <- base::inherits
[15:32:50.461]                       invokeRestart <- base::invokeRestart
[15:32:50.461]                       is.null <- base::is.null
[15:32:50.461]                       muffled <- FALSE
[15:32:50.461]                       if (inherits(cond, "message")) {
[15:32:50.461]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.461]                         if (muffled) 
[15:32:50.461]                           invokeRestart("muffleMessage")
[15:32:50.461]                       }
[15:32:50.461]                       else if (inherits(cond, "warning")) {
[15:32:50.461]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.461]                         if (muffled) 
[15:32:50.461]                           invokeRestart("muffleWarning")
[15:32:50.461]                       }
[15:32:50.461]                       else if (inherits(cond, "condition")) {
[15:32:50.461]                         if (!is.null(pattern)) {
[15:32:50.461]                           computeRestarts <- base::computeRestarts
[15:32:50.461]                           grepl <- base::grepl
[15:32:50.461]                           restarts <- computeRestarts(cond)
[15:32:50.461]                           for (restart in restarts) {
[15:32:50.461]                             name <- restart$name
[15:32:50.461]                             if (is.null(name)) 
[15:32:50.461]                               next
[15:32:50.461]                             if (!grepl(pattern, name)) 
[15:32:50.461]                               next
[15:32:50.461]                             invokeRestart(restart)
[15:32:50.461]                             muffled <- TRUE
[15:32:50.461]                             break
[15:32:50.461]                           }
[15:32:50.461]                         }
[15:32:50.461]                       }
[15:32:50.461]                       invisible(muffled)
[15:32:50.461]                     }
[15:32:50.461]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.461]                   }
[15:32:50.461]                 }
[15:32:50.461]             }
[15:32:50.461]         }))
[15:32:50.461]     }, error = function(ex) {
[15:32:50.461]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:50.461]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.461]                 ...future.rng), started = ...future.startTime, 
[15:32:50.461]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:50.461]             version = "1.8"), class = "FutureResult")
[15:32:50.461]     }, finally = {
[15:32:50.461]         if (!identical(...future.workdir, getwd())) 
[15:32:50.461]             setwd(...future.workdir)
[15:32:50.461]         {
[15:32:50.461]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:50.461]                 ...future.oldOptions$nwarnings <- NULL
[15:32:50.461]             }
[15:32:50.461]             base::options(...future.oldOptions)
[15:32:50.461]             if (.Platform$OS.type == "windows") {
[15:32:50.461]                 old_names <- names(...future.oldEnvVars)
[15:32:50.461]                 envs <- base::Sys.getenv()
[15:32:50.461]                 names <- names(envs)
[15:32:50.461]                 common <- intersect(names, old_names)
[15:32:50.461]                 added <- setdiff(names, old_names)
[15:32:50.461]                 removed <- setdiff(old_names, names)
[15:32:50.461]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:50.461]                   envs[common]]
[15:32:50.461]                 NAMES <- toupper(changed)
[15:32:50.461]                 args <- list()
[15:32:50.461]                 for (kk in seq_along(NAMES)) {
[15:32:50.461]                   name <- changed[[kk]]
[15:32:50.461]                   NAME <- NAMES[[kk]]
[15:32:50.461]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.461]                     next
[15:32:50.461]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.461]                 }
[15:32:50.461]                 NAMES <- toupper(added)
[15:32:50.461]                 for (kk in seq_along(NAMES)) {
[15:32:50.461]                   name <- added[[kk]]
[15:32:50.461]                   NAME <- NAMES[[kk]]
[15:32:50.461]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.461]                     next
[15:32:50.461]                   args[[name]] <- ""
[15:32:50.461]                 }
[15:32:50.461]                 NAMES <- toupper(removed)
[15:32:50.461]                 for (kk in seq_along(NAMES)) {
[15:32:50.461]                   name <- removed[[kk]]
[15:32:50.461]                   NAME <- NAMES[[kk]]
[15:32:50.461]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.461]                     next
[15:32:50.461]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.461]                 }
[15:32:50.461]                 if (length(args) > 0) 
[15:32:50.461]                   base::do.call(base::Sys.setenv, args = args)
[15:32:50.461]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:50.461]             }
[15:32:50.461]             else {
[15:32:50.461]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:50.461]             }
[15:32:50.461]             {
[15:32:50.461]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:50.461]                   0L) {
[15:32:50.461]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:50.461]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:50.461]                   base::options(opts)
[15:32:50.461]                 }
[15:32:50.461]                 {
[15:32:50.461]                   {
[15:32:50.461]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:50.461]                     NULL
[15:32:50.461]                   }
[15:32:50.461]                   options(future.plan = NULL)
[15:32:50.461]                   if (is.na(NA_character_)) 
[15:32:50.461]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.461]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:50.461]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:50.461]                     .init = FALSE)
[15:32:50.461]                 }
[15:32:50.461]             }
[15:32:50.461]         }
[15:32:50.461]     })
[15:32:50.461]     if (TRUE) {
[15:32:50.461]         base::sink(type = "output", split = FALSE)
[15:32:50.461]         if (TRUE) {
[15:32:50.461]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:50.461]         }
[15:32:50.461]         else {
[15:32:50.461]             ...future.result["stdout"] <- base::list(NULL)
[15:32:50.461]         }
[15:32:50.461]         base::close(...future.stdout)
[15:32:50.461]         ...future.stdout <- NULL
[15:32:50.461]     }
[15:32:50.461]     ...future.result$conditions <- ...future.conditions
[15:32:50.461]     ...future.result$finished <- base::Sys.time()
[15:32:50.461]     ...future.result
[15:32:50.461] }
[15:32:50.470] Exporting 11 global objects (91.99 KiB) to cluster node #1 ...
[15:32:50.470] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:50.471] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:50.472] Exporting 'x_FUN' (56 bytes) to cluster node #1 ...
[15:32:50.472] Exporting 'x_FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:50.473] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:50.474] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:50.474] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:50.475] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:50.475] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:50.475] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:50.476] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:50.476] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:50.477] Exporting 'valid_types' (112 bytes) to cluster node #1 ...
[15:32:50.477] Exporting 'valid_types' (112 bytes) to cluster node #1 ... DONE
[15:32:50.478] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:50.479] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:50.479] Exporting '...future.elements_ii' (1.78 KiB) to cluster node #1 ...
[15:32:50.480] Exporting '...future.elements_ii' (1.78 KiB) to cluster node #1 ... DONE
[15:32:50.480] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:50.480] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:50.481] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:50.481] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:50.482] Exporting 11 global objects (91.99 KiB) to cluster node #1 ... DONE
[15:32:50.483] MultisessionFuture started
[15:32:50.483] - Launch lazy future ... done
[15:32:50.483] run() for 'MultisessionFuture' ... done
[15:32:50.484] Created future:
[15:32:50.508] receiveMessageFromWorker() for ClusterFuture ...
[15:32:50.509] - Validating connection of MultisessionFuture
[15:32:50.509] - received message: FutureResult
[15:32:50.510] - Received FutureResult
[15:32:50.510] - Erased future from FutureRegistry
[15:32:50.510] result() for ClusterFuture ...
[15:32:50.511] - result already collected: FutureResult
[15:32:50.511] result() for ClusterFuture ... done
[15:32:50.511] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:50.484] MultisessionFuture:
[15:32:50.484] Label: 'future_vapply-1'
[15:32:50.484] Expression:
[15:32:50.484] {
[15:32:50.484]     do.call(function(...) {
[15:32:50.484]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.484]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.484]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.484]             on.exit(options(oopts), add = TRUE)
[15:32:50.484]         }
[15:32:50.484]         {
[15:32:50.484]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.484]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.484]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.484]             })
[15:32:50.484]         }
[15:32:50.484]     }, args = future.call.arguments)
[15:32:50.484] }
[15:32:50.484] Lazy evaluation: FALSE
[15:32:50.484] Asynchronous evaluation: TRUE
[15:32:50.484] Local evaluation: TRUE
[15:32:50.484] Environment: R_GlobalEnv
[15:32:50.484] Capture standard output: TRUE
[15:32:50.484] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:50.484] Globals: 11 objects totaling 93.77 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 56 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:50.484] Packages: 1 packages ('future.apply')
[15:32:50.484] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:50.484] Resolved: TRUE
[15:32:50.484] Value: <not collected>
[15:32:50.484] Conditions captured: <none>
[15:32:50.484] Early signaling: FALSE
[15:32:50.484] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:50.484] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.512] Chunk #1 of 2 ... DONE
[15:32:50.512] Chunk #2 of 2 ...
[15:32:50.513]  - Finding globals in 'X' for chunk #2 ...
[15:32:50.513] getGlobalsAndPackages() ...
[15:32:50.513] Searching for globals...
[15:32:50.514] 
[15:32:50.514] Searching for globals ... DONE
[15:32:50.514] - globals: [0] <none>
[15:32:50.515] getGlobalsAndPackages() ... DONE
[15:32:50.515]    + additional globals found: [n=0] 
[15:32:50.515]    + additional namespaces needed: [n=0] 
[15:32:50.515]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:50.516]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:50.516]  - seeds: <none>
[15:32:50.516]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.516] getGlobalsAndPackages() ...
[15:32:50.517] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.517] Resolving globals: FALSE
[15:32:50.517] Tweak future expression to call with '...' arguments ...
[15:32:50.517] {
[15:32:50.517]     do.call(function(...) {
[15:32:50.517]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.517]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.517]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.517]             on.exit(options(oopts), add = TRUE)
[15:32:50.517]         }
[15:32:50.517]         {
[15:32:50.517]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.517]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.517]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.517]             })
[15:32:50.517]         }
[15:32:50.517]     }, args = future.call.arguments)
[15:32:50.517] }
[15:32:50.518] Tweak future expression to call with '...' arguments ... DONE
[15:32:50.519] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.519] - packages: [1] 'future.apply'
[15:32:50.520] getGlobalsAndPackages() ... DONE
[15:32:50.520] run() for 'Future' ...
[15:32:50.520] - state: 'created'
[15:32:50.520] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:50.536] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.537] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:50.537]   - Field: 'node'
[15:32:50.537]   - Field: 'label'
[15:32:50.538]   - Field: 'local'
[15:32:50.538]   - Field: 'owner'
[15:32:50.538]   - Field: 'envir'
[15:32:50.538]   - Field: 'workers'
[15:32:50.539]   - Field: 'packages'
[15:32:50.539]   - Field: 'gc'
[15:32:50.539]   - Field: 'conditions'
[15:32:50.540]   - Field: 'persistent'
[15:32:50.540]   - Field: 'expr'
[15:32:50.540]   - Field: 'uuid'
[15:32:50.541]   - Field: 'seed'
[15:32:50.541]   - Field: 'version'
[15:32:50.541]   - Field: 'result'
[15:32:50.541]   - Field: 'asynchronous'
[15:32:50.542]   - Field: 'calls'
[15:32:50.542]   - Field: 'globals'
[15:32:50.542]   - Field: 'stdout'
[15:32:50.543]   - Field: 'earlySignal'
[15:32:50.543]   - Field: 'lazy'
[15:32:50.543]   - Field: 'state'
[15:32:50.544] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:50.544] - Launch lazy future ...
[15:32:50.544] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:50.545] Packages needed by future strategies (n = 0): <none>
[15:32:50.546] {
[15:32:50.546]     {
[15:32:50.546]         {
[15:32:50.546]             ...future.startTime <- base::Sys.time()
[15:32:50.546]             {
[15:32:50.546]                 {
[15:32:50.546]                   {
[15:32:50.546]                     {
[15:32:50.546]                       {
[15:32:50.546]                         base::local({
[15:32:50.546]                           has_future <- base::requireNamespace("future", 
[15:32:50.546]                             quietly = TRUE)
[15:32:50.546]                           if (has_future) {
[15:32:50.546]                             ns <- base::getNamespace("future")
[15:32:50.546]                             version <- ns[[".package"]][["version"]]
[15:32:50.546]                             if (is.null(version)) 
[15:32:50.546]                               version <- utils::packageVersion("future")
[15:32:50.546]                           }
[15:32:50.546]                           else {
[15:32:50.546]                             version <- NULL
[15:32:50.546]                           }
[15:32:50.546]                           if (!has_future || version < "1.8.0") {
[15:32:50.546]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:50.546]                               "", base::R.version$version.string), 
[15:32:50.546]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:50.546]                                 base::R.version$platform, 8 * 
[15:32:50.546]                                   base::.Machine$sizeof.pointer), 
[15:32:50.546]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:50.546]                                 "release", "version")], collapse = " "), 
[15:32:50.546]                               hostname = base::Sys.info()[["nodename"]])
[15:32:50.546]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:50.546]                               info)
[15:32:50.546]                             info <- base::paste(info, collapse = "; ")
[15:32:50.546]                             if (!has_future) {
[15:32:50.546]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:50.546]                                 info)
[15:32:50.546]                             }
[15:32:50.546]                             else {
[15:32:50.546]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:50.546]                                 info, version)
[15:32:50.546]                             }
[15:32:50.546]                             base::stop(msg)
[15:32:50.546]                           }
[15:32:50.546]                         })
[15:32:50.546]                       }
[15:32:50.546]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:50.546]                       base::options(mc.cores = 1L)
[15:32:50.546]                     }
[15:32:50.546]                     base::local({
[15:32:50.546]                       for (pkg in "future.apply") {
[15:32:50.546]                         base::loadNamespace(pkg)
[15:32:50.546]                         base::library(pkg, character.only = TRUE)
[15:32:50.546]                       }
[15:32:50.546]                     })
[15:32:50.546]                   }
[15:32:50.546]                   ...future.strategy.old <- future::plan("list")
[15:32:50.546]                   options(future.plan = NULL)
[15:32:50.546]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.546]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:50.546]                 }
[15:32:50.546]                 ...future.workdir <- getwd()
[15:32:50.546]             }
[15:32:50.546]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:50.546]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:50.546]         }
[15:32:50.546]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:50.546]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:50.546]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:50.546]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:50.546]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:50.546]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:50.546]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:50.546]             base::names(...future.oldOptions))
[15:32:50.546]     }
[15:32:50.546]     if (FALSE) {
[15:32:50.546]     }
[15:32:50.546]     else {
[15:32:50.546]         if (TRUE) {
[15:32:50.546]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:50.546]                 open = "w")
[15:32:50.546]         }
[15:32:50.546]         else {
[15:32:50.546]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:50.546]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:50.546]         }
[15:32:50.546]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:50.546]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:50.546]             base::sink(type = "output", split = FALSE)
[15:32:50.546]             base::close(...future.stdout)
[15:32:50.546]         }, add = TRUE)
[15:32:50.546]     }
[15:32:50.546]     ...future.frame <- base::sys.nframe()
[15:32:50.546]     ...future.conditions <- base::list()
[15:32:50.546]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:50.546]     if (FALSE) {
[15:32:50.546]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:50.546]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:50.546]     }
[15:32:50.546]     ...future.result <- base::tryCatch({
[15:32:50.546]         base::withCallingHandlers({
[15:32:50.546]             ...future.value <- base::withVisible(base::local({
[15:32:50.546]                 ...future.makeSendCondition <- base::local({
[15:32:50.546]                   sendCondition <- NULL
[15:32:50.546]                   function(frame = 1L) {
[15:32:50.546]                     if (is.function(sendCondition)) 
[15:32:50.546]                       return(sendCondition)
[15:32:50.546]                     ns <- getNamespace("parallel")
[15:32:50.546]                     if (exists("sendData", mode = "function", 
[15:32:50.546]                       envir = ns)) {
[15:32:50.546]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:50.546]                         envir = ns)
[15:32:50.546]                       envir <- sys.frame(frame)
[15:32:50.546]                       master <- NULL
[15:32:50.546]                       while (!identical(envir, .GlobalEnv) && 
[15:32:50.546]                         !identical(envir, emptyenv())) {
[15:32:50.546]                         if (exists("master", mode = "list", envir = envir, 
[15:32:50.546]                           inherits = FALSE)) {
[15:32:50.546]                           master <- get("master", mode = "list", 
[15:32:50.546]                             envir = envir, inherits = FALSE)
[15:32:50.546]                           if (inherits(master, c("SOCKnode", 
[15:32:50.546]                             "SOCK0node"))) {
[15:32:50.546]                             sendCondition <<- function(cond) {
[15:32:50.546]                               data <- list(type = "VALUE", value = cond, 
[15:32:50.546]                                 success = TRUE)
[15:32:50.546]                               parallel_sendData(master, data)
[15:32:50.546]                             }
[15:32:50.546]                             return(sendCondition)
[15:32:50.546]                           }
[15:32:50.546]                         }
[15:32:50.546]                         frame <- frame + 1L
[15:32:50.546]                         envir <- sys.frame(frame)
[15:32:50.546]                       }
[15:32:50.546]                     }
[15:32:50.546]                     sendCondition <<- function(cond) NULL
[15:32:50.546]                   }
[15:32:50.546]                 })
[15:32:50.546]                 withCallingHandlers({
[15:32:50.546]                   {
[15:32:50.546]                     do.call(function(...) {
[15:32:50.546]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.546]                       if (!identical(...future.globals.maxSize.org, 
[15:32:50.546]                         ...future.globals.maxSize)) {
[15:32:50.546]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.546]                         on.exit(options(oopts), add = TRUE)
[15:32:50.546]                       }
[15:32:50.546]                       {
[15:32:50.546]                         lapply(seq_along(...future.elements_ii), 
[15:32:50.546]                           FUN = function(jj) {
[15:32:50.546]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.546]                             ...future.FUN(...future.X_jj, ...)
[15:32:50.546]                           })
[15:32:50.546]                       }
[15:32:50.546]                     }, args = future.call.arguments)
[15:32:50.546]                   }
[15:32:50.546]                 }, immediateCondition = function(cond) {
[15:32:50.546]                   sendCondition <- ...future.makeSendCondition()
[15:32:50.546]                   sendCondition(cond)
[15:32:50.546]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.546]                   {
[15:32:50.546]                     inherits <- base::inherits
[15:32:50.546]                     invokeRestart <- base::invokeRestart
[15:32:50.546]                     is.null <- base::is.null
[15:32:50.546]                     muffled <- FALSE
[15:32:50.546]                     if (inherits(cond, "message")) {
[15:32:50.546]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:50.546]                       if (muffled) 
[15:32:50.546]                         invokeRestart("muffleMessage")
[15:32:50.546]                     }
[15:32:50.546]                     else if (inherits(cond, "warning")) {
[15:32:50.546]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:50.546]                       if (muffled) 
[15:32:50.546]                         invokeRestart("muffleWarning")
[15:32:50.546]                     }
[15:32:50.546]                     else if (inherits(cond, "condition")) {
[15:32:50.546]                       if (!is.null(pattern)) {
[15:32:50.546]                         computeRestarts <- base::computeRestarts
[15:32:50.546]                         grepl <- base::grepl
[15:32:50.546]                         restarts <- computeRestarts(cond)
[15:32:50.546]                         for (restart in restarts) {
[15:32:50.546]                           name <- restart$name
[15:32:50.546]                           if (is.null(name)) 
[15:32:50.546]                             next
[15:32:50.546]                           if (!grepl(pattern, name)) 
[15:32:50.546]                             next
[15:32:50.546]                           invokeRestart(restart)
[15:32:50.546]                           muffled <- TRUE
[15:32:50.546]                           break
[15:32:50.546]                         }
[15:32:50.546]                       }
[15:32:50.546]                     }
[15:32:50.546]                     invisible(muffled)
[15:32:50.546]                   }
[15:32:50.546]                   muffleCondition(cond)
[15:32:50.546]                 })
[15:32:50.546]             }))
[15:32:50.546]             future::FutureResult(value = ...future.value$value, 
[15:32:50.546]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.546]                   ...future.rng), globalenv = if (FALSE) 
[15:32:50.546]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:50.546]                     ...future.globalenv.names))
[15:32:50.546]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:50.546]         }, condition = base::local({
[15:32:50.546]             c <- base::c
[15:32:50.546]             inherits <- base::inherits
[15:32:50.546]             invokeRestart <- base::invokeRestart
[15:32:50.546]             length <- base::length
[15:32:50.546]             list <- base::list
[15:32:50.546]             seq.int <- base::seq.int
[15:32:50.546]             signalCondition <- base::signalCondition
[15:32:50.546]             sys.calls <- base::sys.calls
[15:32:50.546]             `[[` <- base::`[[`
[15:32:50.546]             `+` <- base::`+`
[15:32:50.546]             `<<-` <- base::`<<-`
[15:32:50.546]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:50.546]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:50.546]                   3L)]
[15:32:50.546]             }
[15:32:50.546]             function(cond) {
[15:32:50.546]                 is_error <- inherits(cond, "error")
[15:32:50.546]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:50.546]                   NULL)
[15:32:50.546]                 if (is_error) {
[15:32:50.546]                   sessionInformation <- function() {
[15:32:50.546]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:50.546]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:50.546]                       search = base::search(), system = base::Sys.info())
[15:32:50.546]                   }
[15:32:50.546]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.546]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:50.546]                     cond$call), session = sessionInformation(), 
[15:32:50.546]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:50.546]                   signalCondition(cond)
[15:32:50.546]                 }
[15:32:50.546]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:50.546]                 "immediateCondition"))) {
[15:32:50.546]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:50.546]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.546]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:50.546]                   if (TRUE && !signal) {
[15:32:50.546]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.546]                     {
[15:32:50.546]                       inherits <- base::inherits
[15:32:50.546]                       invokeRestart <- base::invokeRestart
[15:32:50.546]                       is.null <- base::is.null
[15:32:50.546]                       muffled <- FALSE
[15:32:50.546]                       if (inherits(cond, "message")) {
[15:32:50.546]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.546]                         if (muffled) 
[15:32:50.546]                           invokeRestart("muffleMessage")
[15:32:50.546]                       }
[15:32:50.546]                       else if (inherits(cond, "warning")) {
[15:32:50.546]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.546]                         if (muffled) 
[15:32:50.546]                           invokeRestart("muffleWarning")
[15:32:50.546]                       }
[15:32:50.546]                       else if (inherits(cond, "condition")) {
[15:32:50.546]                         if (!is.null(pattern)) {
[15:32:50.546]                           computeRestarts <- base::computeRestarts
[15:32:50.546]                           grepl <- base::grepl
[15:32:50.546]                           restarts <- computeRestarts(cond)
[15:32:50.546]                           for (restart in restarts) {
[15:32:50.546]                             name <- restart$name
[15:32:50.546]                             if (is.null(name)) 
[15:32:50.546]                               next
[15:32:50.546]                             if (!grepl(pattern, name)) 
[15:32:50.546]                               next
[15:32:50.546]                             invokeRestart(restart)
[15:32:50.546]                             muffled <- TRUE
[15:32:50.546]                             break
[15:32:50.546]                           }
[15:32:50.546]                         }
[15:32:50.546]                       }
[15:32:50.546]                       invisible(muffled)
[15:32:50.546]                     }
[15:32:50.546]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.546]                   }
[15:32:50.546]                 }
[15:32:50.546]                 else {
[15:32:50.546]                   if (TRUE) {
[15:32:50.546]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.546]                     {
[15:32:50.546]                       inherits <- base::inherits
[15:32:50.546]                       invokeRestart <- base::invokeRestart
[15:32:50.546]                       is.null <- base::is.null
[15:32:50.546]                       muffled <- FALSE
[15:32:50.546]                       if (inherits(cond, "message")) {
[15:32:50.546]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.546]                         if (muffled) 
[15:32:50.546]                           invokeRestart("muffleMessage")
[15:32:50.546]                       }
[15:32:50.546]                       else if (inherits(cond, "warning")) {
[15:32:50.546]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.546]                         if (muffled) 
[15:32:50.546]                           invokeRestart("muffleWarning")
[15:32:50.546]                       }
[15:32:50.546]                       else if (inherits(cond, "condition")) {
[15:32:50.546]                         if (!is.null(pattern)) {
[15:32:50.546]                           computeRestarts <- base::computeRestarts
[15:32:50.546]                           grepl <- base::grepl
[15:32:50.546]                           restarts <- computeRestarts(cond)
[15:32:50.546]                           for (restart in restarts) {
[15:32:50.546]                             name <- restart$name
[15:32:50.546]                             if (is.null(name)) 
[15:32:50.546]                               next
[15:32:50.546]                             if (!grepl(pattern, name)) 
[15:32:50.546]                               next
[15:32:50.546]                             invokeRestart(restart)
[15:32:50.546]                             muffled <- TRUE
[15:32:50.546]                             break
[15:32:50.546]                           }
[15:32:50.546]                         }
[15:32:50.546]                       }
[15:32:50.546]                       invisible(muffled)
[15:32:50.546]                     }
[15:32:50.546]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.546]                   }
[15:32:50.546]                 }
[15:32:50.546]             }
[15:32:50.546]         }))
[15:32:50.546]     }, error = function(ex) {
[15:32:50.546]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:50.546]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.546]                 ...future.rng), started = ...future.startTime, 
[15:32:50.546]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:50.546]             version = "1.8"), class = "FutureResult")
[15:32:50.546]     }, finally = {
[15:32:50.546]         if (!identical(...future.workdir, getwd())) 
[15:32:50.546]             setwd(...future.workdir)
[15:32:50.546]         {
[15:32:50.546]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:50.546]                 ...future.oldOptions$nwarnings <- NULL
[15:32:50.546]             }
[15:32:50.546]             base::options(...future.oldOptions)
[15:32:50.546]             if (.Platform$OS.type == "windows") {
[15:32:50.546]                 old_names <- names(...future.oldEnvVars)
[15:32:50.546]                 envs <- base::Sys.getenv()
[15:32:50.546]                 names <- names(envs)
[15:32:50.546]                 common <- intersect(names, old_names)
[15:32:50.546]                 added <- setdiff(names, old_names)
[15:32:50.546]                 removed <- setdiff(old_names, names)
[15:32:50.546]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:50.546]                   envs[common]]
[15:32:50.546]                 NAMES <- toupper(changed)
[15:32:50.546]                 args <- list()
[15:32:50.546]                 for (kk in seq_along(NAMES)) {
[15:32:50.546]                   name <- changed[[kk]]
[15:32:50.546]                   NAME <- NAMES[[kk]]
[15:32:50.546]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.546]                     next
[15:32:50.546]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.546]                 }
[15:32:50.546]                 NAMES <- toupper(added)
[15:32:50.546]                 for (kk in seq_along(NAMES)) {
[15:32:50.546]                   name <- added[[kk]]
[15:32:50.546]                   NAME <- NAMES[[kk]]
[15:32:50.546]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.546]                     next
[15:32:50.546]                   args[[name]] <- ""
[15:32:50.546]                 }
[15:32:50.546]                 NAMES <- toupper(removed)
[15:32:50.546]                 for (kk in seq_along(NAMES)) {
[15:32:50.546]                   name <- removed[[kk]]
[15:32:50.546]                   NAME <- NAMES[[kk]]
[15:32:50.546]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.546]                     next
[15:32:50.546]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.546]                 }
[15:32:50.546]                 if (length(args) > 0) 
[15:32:50.546]                   base::do.call(base::Sys.setenv, args = args)
[15:32:50.546]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:50.546]             }
[15:32:50.546]             else {
[15:32:50.546]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:50.546]             }
[15:32:50.546]             {
[15:32:50.546]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:50.546]                   0L) {
[15:32:50.546]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:50.546]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:50.546]                   base::options(opts)
[15:32:50.546]                 }
[15:32:50.546]                 {
[15:32:50.546]                   {
[15:32:50.546]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:50.546]                     NULL
[15:32:50.546]                   }
[15:32:50.546]                   options(future.plan = NULL)
[15:32:50.546]                   if (is.na(NA_character_)) 
[15:32:50.546]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.546]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:50.546]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:50.546]                     .init = FALSE)
[15:32:50.546]                 }
[15:32:50.546]             }
[15:32:50.546]         }
[15:32:50.546]     })
[15:32:50.546]     if (TRUE) {
[15:32:50.546]         base::sink(type = "output", split = FALSE)
[15:32:50.546]         if (TRUE) {
[15:32:50.546]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:50.546]         }
[15:32:50.546]         else {
[15:32:50.546]             ...future.result["stdout"] <- base::list(NULL)
[15:32:50.546]         }
[15:32:50.546]         base::close(...future.stdout)
[15:32:50.546]         ...future.stdout <- NULL
[15:32:50.546]     }
[15:32:50.546]     ...future.result$conditions <- ...future.conditions
[15:32:50.546]     ...future.result$finished <- base::Sys.time()
[15:32:50.546]     ...future.result
[15:32:50.546] }
[15:32:50.555] Exporting 11 global objects (91.99 KiB) to cluster node #1 ...
[15:32:50.555] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:50.556] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:50.556] Exporting 'x_FUN' (56 bytes) to cluster node #1 ...
[15:32:50.557] Exporting 'x_FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:50.557] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:50.558] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:50.558] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:50.559] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:50.559] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:50.560] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:50.560] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:50.561] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:50.561] Exporting 'valid_types' (112 bytes) to cluster node #1 ...
[15:32:50.562] Exporting 'valid_types' (112 bytes) to cluster node #1 ... DONE
[15:32:50.562] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:50.563] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:50.563] Exporting '...future.elements_ii' (1.48 KiB) to cluster node #1 ...
[15:32:50.564] Exporting '...future.elements_ii' (1.48 KiB) to cluster node #1 ... DONE
[15:32:50.564] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:50.565] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:50.565] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:50.565] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:50.566] Exporting 11 global objects (91.99 KiB) to cluster node #1 ... DONE
[15:32:50.567] MultisessionFuture started
[15:32:50.567] - Launch lazy future ... done
[15:32:50.567] run() for 'MultisessionFuture' ... done
[15:32:50.568] Created future:
[15:32:50.587] receiveMessageFromWorker() for ClusterFuture ...
[15:32:50.587] - Validating connection of MultisessionFuture
[15:32:50.587] - received message: FutureResult
[15:32:50.587] - Received FutureResult
[15:32:50.588] - Erased future from FutureRegistry
[15:32:50.588] result() for ClusterFuture ...
[15:32:50.588] - result already collected: FutureResult
[15:32:50.588] result() for ClusterFuture ... done
[15:32:50.588] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:50.568] MultisessionFuture:
[15:32:50.568] Label: 'future_vapply-2'
[15:32:50.568] Expression:
[15:32:50.568] {
[15:32:50.568]     do.call(function(...) {
[15:32:50.568]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.568]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.568]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.568]             on.exit(options(oopts), add = TRUE)
[15:32:50.568]         }
[15:32:50.568]         {
[15:32:50.568]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.568]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.568]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.568]             })
[15:32:50.568]         }
[15:32:50.568]     }, args = future.call.arguments)
[15:32:50.568] }
[15:32:50.568] Lazy evaluation: FALSE
[15:32:50.568] Asynchronous evaluation: TRUE
[15:32:50.568] Local evaluation: TRUE
[15:32:50.568] Environment: R_GlobalEnv
[15:32:50.568] Capture standard output: TRUE
[15:32:50.568] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:50.568] Globals: 11 objects totaling 93.48 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 56 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:50.568] Packages: 1 packages ('future.apply')
[15:32:50.568] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:50.568] Resolved: TRUE
[15:32:50.568] Value: <not collected>
[15:32:50.568] Conditions captured: <none>
[15:32:50.568] Early signaling: FALSE
[15:32:50.568] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:50.568] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.589] Chunk #2 of 2 ... DONE
[15:32:50.589] Launching 2 futures (chunks) ... DONE
[15:32:50.590] Resolving 2 futures (chunks) ...
[15:32:50.590] resolve() on list ...
[15:32:50.590]  recursive: 0
[15:32:50.590]  length: 2
[15:32:50.590] 
[15:32:50.590] Future #1
[15:32:50.591] result() for ClusterFuture ...
[15:32:50.591] - result already collected: FutureResult
[15:32:50.591] result() for ClusterFuture ... done
[15:32:50.591] result() for ClusterFuture ...
[15:32:50.591] - result already collected: FutureResult
[15:32:50.591] result() for ClusterFuture ... done
[15:32:50.592] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:50.592] - nx: 2
[15:32:50.592] - relay: TRUE
[15:32:50.592] - stdout: TRUE
[15:32:50.592] - signal: TRUE
[15:32:50.592] - resignal: FALSE
[15:32:50.593] - force: TRUE
[15:32:50.593] - relayed: [n=2] FALSE, FALSE
[15:32:50.593] - queued futures: [n=2] FALSE, FALSE
[15:32:50.593]  - until=1
[15:32:50.593]  - relaying element #1
[15:32:50.594] result() for ClusterFuture ...
[15:32:50.594] - result already collected: FutureResult
[15:32:50.594] result() for ClusterFuture ... done
[15:32:50.594] result() for ClusterFuture ...
[15:32:50.595] - result already collected: FutureResult
[15:32:50.595] result() for ClusterFuture ... done
[15:32:50.595] result() for ClusterFuture ...
[15:32:50.595] - result already collected: FutureResult
[15:32:50.595] result() for ClusterFuture ... done
[15:32:50.596] result() for ClusterFuture ...
[15:32:50.596] - result already collected: FutureResult
[15:32:50.596] result() for ClusterFuture ... done
[15:32:50.596] - relayed: [n=2] TRUE, FALSE
[15:32:50.596] - queued futures: [n=2] TRUE, FALSE
[15:32:50.596] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:50.597]  length: 1 (resolved future 1)
[15:32:50.597] Future #2
[15:32:50.597] result() for ClusterFuture ...
[15:32:50.597] - result already collected: FutureResult
[15:32:50.597] result() for ClusterFuture ... done
[15:32:50.598] result() for ClusterFuture ...
[15:32:50.598] - result already collected: FutureResult
[15:32:50.598] result() for ClusterFuture ... done
[15:32:50.598] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:50.598] - nx: 2
[15:32:50.598] - relay: TRUE
[15:32:50.599] - stdout: TRUE
[15:32:50.599] - signal: TRUE
[15:32:50.599] - resignal: FALSE
[15:32:50.599] - force: TRUE
[15:32:50.599] - relayed: [n=2] TRUE, FALSE
[15:32:50.599] - queued futures: [n=2] TRUE, FALSE
[15:32:50.600]  - until=2
[15:32:50.600]  - relaying element #2
[15:32:50.600] result() for ClusterFuture ...
[15:32:50.600] - result already collected: FutureResult
[15:32:50.600] result() for ClusterFuture ... done
[15:32:50.600] result() for ClusterFuture ...
[15:32:50.600] - result already collected: FutureResult
[15:32:50.601] result() for ClusterFuture ... done
[15:32:50.601] result() for ClusterFuture ...
[15:32:50.601] - result already collected: FutureResult
[15:32:50.601] result() for ClusterFuture ... done
[15:32:50.601] result() for ClusterFuture ...
[15:32:50.601] - result already collected: FutureResult
[15:32:50.602] result() for ClusterFuture ... done
[15:32:50.602] - relayed: [n=2] TRUE, TRUE
[15:32:50.602] - queued futures: [n=2] TRUE, TRUE
[15:32:50.602] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:50.602]  length: 0 (resolved future 2)
[15:32:50.602] Relaying remaining futures
[15:32:50.603] signalConditionsASAP(NULL, pos=0) ...
[15:32:50.603] - nx: 2
[15:32:50.603] - relay: TRUE
[15:32:50.603] - stdout: TRUE
[15:32:50.603] - signal: TRUE
[15:32:50.603] - resignal: FALSE
[15:32:50.604] - force: TRUE
[15:32:50.604] - relayed: [n=2] TRUE, TRUE
[15:32:50.604] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:50.604] - relayed: [n=2] TRUE, TRUE
[15:32:50.604] - queued futures: [n=2] TRUE, TRUE
[15:32:50.604] signalConditionsASAP(NULL, pos=0) ... done
[15:32:50.605] resolve() on list ... DONE
[15:32:50.605] result() for ClusterFuture ...
[15:32:50.605] - result already collected: FutureResult
[15:32:50.605] result() for ClusterFuture ... done
[15:32:50.605] result() for ClusterFuture ...
[15:32:50.605] - result already collected: FutureResult
[15:32:50.606] result() for ClusterFuture ... done
[15:32:50.606] result() for ClusterFuture ...
[15:32:50.606] - result already collected: FutureResult
[15:32:50.606] result() for ClusterFuture ... done
[15:32:50.606] result() for ClusterFuture ...
[15:32:50.606] - result already collected: FutureResult
[15:32:50.607] result() for ClusterFuture ... done
[15:32:50.607]  - Number of value chunks collected: 2
[15:32:50.607] Resolving 2 futures (chunks) ... DONE
[15:32:50.607] Reducing values from 2 chunks ...
[15:32:50.607]  - Number of values collected after concatenation: 11
[15:32:50.607]  - Number of values expected: 11
[15:32:50.608] Reducing values from 2 chunks ... DONE
[15:32:50.608] future_lapply() ... DONE
 Named logi [1:11] TRUE TRUE TRUE TRUE TRUE TRUE ...
 - attr(*, "names")= chr [1:11] "mpg" "cyl" "disp" "hp" ...
- future_vapply(x, ...) where length(x) != length(as.list(x)) ...
[15:32:50.609] future_lapply() ...
[15:32:50.618] Number of chunks: 2
[15:32:50.618] getGlobalsAndPackagesXApply() ...
[15:32:50.618]  - future.globals: TRUE
[15:32:50.619] getGlobalsAndPackages() ...
[15:32:50.619] Searching for globals...
[15:32:50.625] - globals found: [16] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types'
[15:32:50.625] Searching for globals ... DONE
[15:32:50.626] Resolving globals: FALSE
[15:32:50.627] The total size of the 7 globals is 92.05 KiB (94264 bytes)
[15:32:50.629] The total size of the 7 globals exported for future expression ('FUN()') is 92.05 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:50.629] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:50.629] - packages: [1] 'future.apply'
[15:32:50.630] getGlobalsAndPackages() ... DONE
[15:32:50.630]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:50.630]  - needed namespaces: [n=1] 'future.apply'
[15:32:50.630] Finding globals ... DONE
[15:32:50.631]  - use_args: TRUE
[15:32:50.631]  - Getting '...' globals ...
[15:32:50.632] resolve() on list ...
[15:32:50.632]  recursive: 0
[15:32:50.632]  length: 1
[15:32:50.632]  elements: '...'
[15:32:50.633]  length: 0 (resolved future 1)
[15:32:50.633] resolve() on list ... DONE
[15:32:50.633]    - '...' content: [n=0] 
[15:32:50.634] List of 1
[15:32:50.634]  $ ...: list()
[15:32:50.634]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:50.634]  - attr(*, "where")=List of 1
[15:32:50.634]   ..$ ...:<environment: 0x0000022d4112faa8> 
[15:32:50.634]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:50.634]  - attr(*, "resolved")= logi TRUE
[15:32:50.634]  - attr(*, "total_size")= num NA
[15:32:50.639]  - Getting '...' globals ... DONE
[15:32:50.639] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:50.639] List of 8
[15:32:50.639]  $ ...future.FUN:function (x, ...)  
[15:32:50.639]  $ x_FUN        :function (x)  
[15:32:50.639]  $ times        : int 1
[15:32:50.639]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:50.639]  $ stop_if_not  :function (...)  
[15:32:50.639]  $ dim          : NULL
[15:32:50.639]  $ valid_types  : chr [1:2] "logical" "integer"
[15:32:50.639]  $ ...          : list()
[15:32:50.639]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:50.639]  - attr(*, "where")=List of 8
[15:32:50.639]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:50.639]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:50.639]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:50.639]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:50.639]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:50.639]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:50.639]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:50.639]   ..$ ...          :<environment: 0x0000022d4112faa8> 
[15:32:50.639]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:50.639]  - attr(*, "resolved")= logi FALSE
[15:32:50.639]  - attr(*, "total_size")= num 94264
[15:32:50.650] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:50.650] getGlobalsAndPackagesXApply() ... DONE
[15:32:50.651] Number of futures (= number of chunks): 2
[15:32:50.651] Launching 2 futures (chunks) ...
[15:32:50.651] Chunk #1 of 2 ...
[15:32:50.652]  - Finding globals in 'X' for chunk #1 ...
[15:32:50.652] getGlobalsAndPackages() ...
[15:32:50.652] Searching for globals...
[15:32:50.653] 
[15:32:50.653] Searching for globals ... DONE
[15:32:50.653] - globals: [0] <none>
[15:32:50.654] getGlobalsAndPackages() ... DONE
[15:32:50.654]    + additional globals found: [n=0] 
[15:32:50.654]    + additional namespaces needed: [n=0] 
[15:32:50.654]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:50.655]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:50.655]  - seeds: <none>
[15:32:50.655]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.656] getGlobalsAndPackages() ...
[15:32:50.656] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.656] Resolving globals: FALSE
[15:32:50.657] Tweak future expression to call with '...' arguments ...
[15:32:50.657] {
[15:32:50.657]     do.call(function(...) {
[15:32:50.657]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.657]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.657]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.657]             on.exit(options(oopts), add = TRUE)
[15:32:50.657]         }
[15:32:50.657]         {
[15:32:50.657]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.657]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.657]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.657]             })
[15:32:50.657]         }
[15:32:50.657]     }, args = future.call.arguments)
[15:32:50.657] }
[15:32:50.658] Tweak future expression to call with '...' arguments ... DONE
[15:32:50.659] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.659] - packages: [1] 'future.apply'
[15:32:50.660] getGlobalsAndPackages() ... DONE
[15:32:50.660] run() for 'Future' ...
[15:32:50.661] - state: 'created'
[15:32:50.661] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:50.679] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.679] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:50.680]   - Field: 'node'
[15:32:50.680]   - Field: 'label'
[15:32:50.680]   - Field: 'local'
[15:32:50.681]   - Field: 'owner'
[15:32:50.681]   - Field: 'envir'
[15:32:50.681]   - Field: 'workers'
[15:32:50.681]   - Field: 'packages'
[15:32:50.682]   - Field: 'gc'
[15:32:50.682]   - Field: 'conditions'
[15:32:50.682]   - Field: 'persistent'
[15:32:50.683]   - Field: 'expr'
[15:32:50.683]   - Field: 'uuid'
[15:32:50.683]   - Field: 'seed'
[15:32:50.684]   - Field: 'version'
[15:32:50.684]   - Field: 'result'
[15:32:50.684]   - Field: 'asynchronous'
[15:32:50.685]   - Field: 'calls'
[15:32:50.685]   - Field: 'globals'
[15:32:50.685]   - Field: 'stdout'
[15:32:50.686]   - Field: 'earlySignal'
[15:32:50.686]   - Field: 'lazy'
[15:32:50.686]   - Field: 'state'
[15:32:50.686] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:50.687] - Launch lazy future ...
[15:32:50.687] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:50.688] Packages needed by future strategies (n = 0): <none>
[15:32:50.741] {
[15:32:50.741]     {
[15:32:50.741]         {
[15:32:50.741]             ...future.startTime <- base::Sys.time()
[15:32:50.741]             {
[15:32:50.741]                 {
[15:32:50.741]                   {
[15:32:50.741]                     {
[15:32:50.741]                       {
[15:32:50.741]                         base::local({
[15:32:50.741]                           has_future <- base::requireNamespace("future", 
[15:32:50.741]                             quietly = TRUE)
[15:32:50.741]                           if (has_future) {
[15:32:50.741]                             ns <- base::getNamespace("future")
[15:32:50.741]                             version <- ns[[".package"]][["version"]]
[15:32:50.741]                             if (is.null(version)) 
[15:32:50.741]                               version <- utils::packageVersion("future")
[15:32:50.741]                           }
[15:32:50.741]                           else {
[15:32:50.741]                             version <- NULL
[15:32:50.741]                           }
[15:32:50.741]                           if (!has_future || version < "1.8.0") {
[15:32:50.741]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:50.741]                               "", base::R.version$version.string), 
[15:32:50.741]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:50.741]                                 base::R.version$platform, 8 * 
[15:32:50.741]                                   base::.Machine$sizeof.pointer), 
[15:32:50.741]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:50.741]                                 "release", "version")], collapse = " "), 
[15:32:50.741]                               hostname = base::Sys.info()[["nodename"]])
[15:32:50.741]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:50.741]                               info)
[15:32:50.741]                             info <- base::paste(info, collapse = "; ")
[15:32:50.741]                             if (!has_future) {
[15:32:50.741]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:50.741]                                 info)
[15:32:50.741]                             }
[15:32:50.741]                             else {
[15:32:50.741]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:50.741]                                 info, version)
[15:32:50.741]                             }
[15:32:50.741]                             base::stop(msg)
[15:32:50.741]                           }
[15:32:50.741]                         })
[15:32:50.741]                       }
[15:32:50.741]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:50.741]                       base::options(mc.cores = 1L)
[15:32:50.741]                     }
[15:32:50.741]                     base::local({
[15:32:50.741]                       for (pkg in "future.apply") {
[15:32:50.741]                         base::loadNamespace(pkg)
[15:32:50.741]                         base::library(pkg, character.only = TRUE)
[15:32:50.741]                       }
[15:32:50.741]                     })
[15:32:50.741]                   }
[15:32:50.741]                   ...future.strategy.old <- future::plan("list")
[15:32:50.741]                   options(future.plan = NULL)
[15:32:50.741]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.741]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:50.741]                 }
[15:32:50.741]                 ...future.workdir <- getwd()
[15:32:50.741]             }
[15:32:50.741]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:50.741]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:50.741]         }
[15:32:50.741]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:50.741]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:50.741]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:50.741]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:50.741]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:50.741]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:50.741]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:50.741]             base::names(...future.oldOptions))
[15:32:50.741]     }
[15:32:50.741]     if (FALSE) {
[15:32:50.741]     }
[15:32:50.741]     else {
[15:32:50.741]         if (TRUE) {
[15:32:50.741]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:50.741]                 open = "w")
[15:32:50.741]         }
[15:32:50.741]         else {
[15:32:50.741]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:50.741]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:50.741]         }
[15:32:50.741]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:50.741]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:50.741]             base::sink(type = "output", split = FALSE)
[15:32:50.741]             base::close(...future.stdout)
[15:32:50.741]         }, add = TRUE)
[15:32:50.741]     }
[15:32:50.741]     ...future.frame <- base::sys.nframe()
[15:32:50.741]     ...future.conditions <- base::list()
[15:32:50.741]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:50.741]     if (FALSE) {
[15:32:50.741]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:50.741]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:50.741]     }
[15:32:50.741]     ...future.result <- base::tryCatch({
[15:32:50.741]         base::withCallingHandlers({
[15:32:50.741]             ...future.value <- base::withVisible(base::local({
[15:32:50.741]                 ...future.makeSendCondition <- base::local({
[15:32:50.741]                   sendCondition <- NULL
[15:32:50.741]                   function(frame = 1L) {
[15:32:50.741]                     if (is.function(sendCondition)) 
[15:32:50.741]                       return(sendCondition)
[15:32:50.741]                     ns <- getNamespace("parallel")
[15:32:50.741]                     if (exists("sendData", mode = "function", 
[15:32:50.741]                       envir = ns)) {
[15:32:50.741]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:50.741]                         envir = ns)
[15:32:50.741]                       envir <- sys.frame(frame)
[15:32:50.741]                       master <- NULL
[15:32:50.741]                       while (!identical(envir, .GlobalEnv) && 
[15:32:50.741]                         !identical(envir, emptyenv())) {
[15:32:50.741]                         if (exists("master", mode = "list", envir = envir, 
[15:32:50.741]                           inherits = FALSE)) {
[15:32:50.741]                           master <- get("master", mode = "list", 
[15:32:50.741]                             envir = envir, inherits = FALSE)
[15:32:50.741]                           if (inherits(master, c("SOCKnode", 
[15:32:50.741]                             "SOCK0node"))) {
[15:32:50.741]                             sendCondition <<- function(cond) {
[15:32:50.741]                               data <- list(type = "VALUE", value = cond, 
[15:32:50.741]                                 success = TRUE)
[15:32:50.741]                               parallel_sendData(master, data)
[15:32:50.741]                             }
[15:32:50.741]                             return(sendCondition)
[15:32:50.741]                           }
[15:32:50.741]                         }
[15:32:50.741]                         frame <- frame + 1L
[15:32:50.741]                         envir <- sys.frame(frame)
[15:32:50.741]                       }
[15:32:50.741]                     }
[15:32:50.741]                     sendCondition <<- function(cond) NULL
[15:32:50.741]                   }
[15:32:50.741]                 })
[15:32:50.741]                 withCallingHandlers({
[15:32:50.741]                   {
[15:32:50.741]                     do.call(function(...) {
[15:32:50.741]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.741]                       if (!identical(...future.globals.maxSize.org, 
[15:32:50.741]                         ...future.globals.maxSize)) {
[15:32:50.741]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.741]                         on.exit(options(oopts), add = TRUE)
[15:32:50.741]                       }
[15:32:50.741]                       {
[15:32:50.741]                         lapply(seq_along(...future.elements_ii), 
[15:32:50.741]                           FUN = function(jj) {
[15:32:50.741]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.741]                             ...future.FUN(...future.X_jj, ...)
[15:32:50.741]                           })
[15:32:50.741]                       }
[15:32:50.741]                     }, args = future.call.arguments)
[15:32:50.741]                   }
[15:32:50.741]                 }, immediateCondition = function(cond) {
[15:32:50.741]                   sendCondition <- ...future.makeSendCondition()
[15:32:50.741]                   sendCondition(cond)
[15:32:50.741]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.741]                   {
[15:32:50.741]                     inherits <- base::inherits
[15:32:50.741]                     invokeRestart <- base::invokeRestart
[15:32:50.741]                     is.null <- base::is.null
[15:32:50.741]                     muffled <- FALSE
[15:32:50.741]                     if (inherits(cond, "message")) {
[15:32:50.741]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:50.741]                       if (muffled) 
[15:32:50.741]                         invokeRestart("muffleMessage")
[15:32:50.741]                     }
[15:32:50.741]                     else if (inherits(cond, "warning")) {
[15:32:50.741]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:50.741]                       if (muffled) 
[15:32:50.741]                         invokeRestart("muffleWarning")
[15:32:50.741]                     }
[15:32:50.741]                     else if (inherits(cond, "condition")) {
[15:32:50.741]                       if (!is.null(pattern)) {
[15:32:50.741]                         computeRestarts <- base::computeRestarts
[15:32:50.741]                         grepl <- base::grepl
[15:32:50.741]                         restarts <- computeRestarts(cond)
[15:32:50.741]                         for (restart in restarts) {
[15:32:50.741]                           name <- restart$name
[15:32:50.741]                           if (is.null(name)) 
[15:32:50.741]                             next
[15:32:50.741]                           if (!grepl(pattern, name)) 
[15:32:50.741]                             next
[15:32:50.741]                           invokeRestart(restart)
[15:32:50.741]                           muffled <- TRUE
[15:32:50.741]                           break
[15:32:50.741]                         }
[15:32:50.741]                       }
[15:32:50.741]                     }
[15:32:50.741]                     invisible(muffled)
[15:32:50.741]                   }
[15:32:50.741]                   muffleCondition(cond)
[15:32:50.741]                 })
[15:32:50.741]             }))
[15:32:50.741]             future::FutureResult(value = ...future.value$value, 
[15:32:50.741]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.741]                   ...future.rng), globalenv = if (FALSE) 
[15:32:50.741]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:50.741]                     ...future.globalenv.names))
[15:32:50.741]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:50.741]         }, condition = base::local({
[15:32:50.741]             c <- base::c
[15:32:50.741]             inherits <- base::inherits
[15:32:50.741]             invokeRestart <- base::invokeRestart
[15:32:50.741]             length <- base::length
[15:32:50.741]             list <- base::list
[15:32:50.741]             seq.int <- base::seq.int
[15:32:50.741]             signalCondition <- base::signalCondition
[15:32:50.741]             sys.calls <- base::sys.calls
[15:32:50.741]             `[[` <- base::`[[`
[15:32:50.741]             `+` <- base::`+`
[15:32:50.741]             `<<-` <- base::`<<-`
[15:32:50.741]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:50.741]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:50.741]                   3L)]
[15:32:50.741]             }
[15:32:50.741]             function(cond) {
[15:32:50.741]                 is_error <- inherits(cond, "error")
[15:32:50.741]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:50.741]                   NULL)
[15:32:50.741]                 if (is_error) {
[15:32:50.741]                   sessionInformation <- function() {
[15:32:50.741]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:50.741]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:50.741]                       search = base::search(), system = base::Sys.info())
[15:32:50.741]                   }
[15:32:50.741]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.741]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:50.741]                     cond$call), session = sessionInformation(), 
[15:32:50.741]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:50.741]                   signalCondition(cond)
[15:32:50.741]                 }
[15:32:50.741]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:50.741]                 "immediateCondition"))) {
[15:32:50.741]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:50.741]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.741]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:50.741]                   if (TRUE && !signal) {
[15:32:50.741]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.741]                     {
[15:32:50.741]                       inherits <- base::inherits
[15:32:50.741]                       invokeRestart <- base::invokeRestart
[15:32:50.741]                       is.null <- base::is.null
[15:32:50.741]                       muffled <- FALSE
[15:32:50.741]                       if (inherits(cond, "message")) {
[15:32:50.741]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.741]                         if (muffled) 
[15:32:50.741]                           invokeRestart("muffleMessage")
[15:32:50.741]                       }
[15:32:50.741]                       else if (inherits(cond, "warning")) {
[15:32:50.741]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.741]                         if (muffled) 
[15:32:50.741]                           invokeRestart("muffleWarning")
[15:32:50.741]                       }
[15:32:50.741]                       else if (inherits(cond, "condition")) {
[15:32:50.741]                         if (!is.null(pattern)) {
[15:32:50.741]                           computeRestarts <- base::computeRestarts
[15:32:50.741]                           grepl <- base::grepl
[15:32:50.741]                           restarts <- computeRestarts(cond)
[15:32:50.741]                           for (restart in restarts) {
[15:32:50.741]                             name <- restart$name
[15:32:50.741]                             if (is.null(name)) 
[15:32:50.741]                               next
[15:32:50.741]                             if (!grepl(pattern, name)) 
[15:32:50.741]                               next
[15:32:50.741]                             invokeRestart(restart)
[15:32:50.741]                             muffled <- TRUE
[15:32:50.741]                             break
[15:32:50.741]                           }
[15:32:50.741]                         }
[15:32:50.741]                       }
[15:32:50.741]                       invisible(muffled)
[15:32:50.741]                     }
[15:32:50.741]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.741]                   }
[15:32:50.741]                 }
[15:32:50.741]                 else {
[15:32:50.741]                   if (TRUE) {
[15:32:50.741]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.741]                     {
[15:32:50.741]                       inherits <- base::inherits
[15:32:50.741]                       invokeRestart <- base::invokeRestart
[15:32:50.741]                       is.null <- base::is.null
[15:32:50.741]                       muffled <- FALSE
[15:32:50.741]                       if (inherits(cond, "message")) {
[15:32:50.741]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.741]                         if (muffled) 
[15:32:50.741]                           invokeRestart("muffleMessage")
[15:32:50.741]                       }
[15:32:50.741]                       else if (inherits(cond, "warning")) {
[15:32:50.741]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.741]                         if (muffled) 
[15:32:50.741]                           invokeRestart("muffleWarning")
[15:32:50.741]                       }
[15:32:50.741]                       else if (inherits(cond, "condition")) {
[15:32:50.741]                         if (!is.null(pattern)) {
[15:32:50.741]                           computeRestarts <- base::computeRestarts
[15:32:50.741]                           grepl <- base::grepl
[15:32:50.741]                           restarts <- computeRestarts(cond)
[15:32:50.741]                           for (restart in restarts) {
[15:32:50.741]                             name <- restart$name
[15:32:50.741]                             if (is.null(name)) 
[15:32:50.741]                               next
[15:32:50.741]                             if (!grepl(pattern, name)) 
[15:32:50.741]                               next
[15:32:50.741]                             invokeRestart(restart)
[15:32:50.741]                             muffled <- TRUE
[15:32:50.741]                             break
[15:32:50.741]                           }
[15:32:50.741]                         }
[15:32:50.741]                       }
[15:32:50.741]                       invisible(muffled)
[15:32:50.741]                     }
[15:32:50.741]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.741]                   }
[15:32:50.741]                 }
[15:32:50.741]             }
[15:32:50.741]         }))
[15:32:50.741]     }, error = function(ex) {
[15:32:50.741]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:50.741]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.741]                 ...future.rng), started = ...future.startTime, 
[15:32:50.741]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:50.741]             version = "1.8"), class = "FutureResult")
[15:32:50.741]     }, finally = {
[15:32:50.741]         if (!identical(...future.workdir, getwd())) 
[15:32:50.741]             setwd(...future.workdir)
[15:32:50.741]         {
[15:32:50.741]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:50.741]                 ...future.oldOptions$nwarnings <- NULL
[15:32:50.741]             }
[15:32:50.741]             base::options(...future.oldOptions)
[15:32:50.741]             if (.Platform$OS.type == "windows") {
[15:32:50.741]                 old_names <- names(...future.oldEnvVars)
[15:32:50.741]                 envs <- base::Sys.getenv()
[15:32:50.741]                 names <- names(envs)
[15:32:50.741]                 common <- intersect(names, old_names)
[15:32:50.741]                 added <- setdiff(names, old_names)
[15:32:50.741]                 removed <- setdiff(old_names, names)
[15:32:50.741]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:50.741]                   envs[common]]
[15:32:50.741]                 NAMES <- toupper(changed)
[15:32:50.741]                 args <- list()
[15:32:50.741]                 for (kk in seq_along(NAMES)) {
[15:32:50.741]                   name <- changed[[kk]]
[15:32:50.741]                   NAME <- NAMES[[kk]]
[15:32:50.741]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.741]                     next
[15:32:50.741]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.741]                 }
[15:32:50.741]                 NAMES <- toupper(added)
[15:32:50.741]                 for (kk in seq_along(NAMES)) {
[15:32:50.741]                   name <- added[[kk]]
[15:32:50.741]                   NAME <- NAMES[[kk]]
[15:32:50.741]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.741]                     next
[15:32:50.741]                   args[[name]] <- ""
[15:32:50.741]                 }
[15:32:50.741]                 NAMES <- toupper(removed)
[15:32:50.741]                 for (kk in seq_along(NAMES)) {
[15:32:50.741]                   name <- removed[[kk]]
[15:32:50.741]                   NAME <- NAMES[[kk]]
[15:32:50.741]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.741]                     next
[15:32:50.741]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.741]                 }
[15:32:50.741]                 if (length(args) > 0) 
[15:32:50.741]                   base::do.call(base::Sys.setenv, args = args)
[15:32:50.741]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:50.741]             }
[15:32:50.741]             else {
[15:32:50.741]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:50.741]             }
[15:32:50.741]             {
[15:32:50.741]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:50.741]                   0L) {
[15:32:50.741]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:50.741]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:50.741]                   base::options(opts)
[15:32:50.741]                 }
[15:32:50.741]                 {
[15:32:50.741]                   {
[15:32:50.741]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:50.741]                     NULL
[15:32:50.741]                   }
[15:32:50.741]                   options(future.plan = NULL)
[15:32:50.741]                   if (is.na(NA_character_)) 
[15:32:50.741]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.741]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:50.741]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:50.741]                     .init = FALSE)
[15:32:50.741]                 }
[15:32:50.741]             }
[15:32:50.741]         }
[15:32:50.741]     })
[15:32:50.741]     if (TRUE) {
[15:32:50.741]         base::sink(type = "output", split = FALSE)
[15:32:50.741]         if (TRUE) {
[15:32:50.741]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:50.741]         }
[15:32:50.741]         else {
[15:32:50.741]             ...future.result["stdout"] <- base::list(NULL)
[15:32:50.741]         }
[15:32:50.741]         base::close(...future.stdout)
[15:32:50.741]         ...future.stdout <- NULL
[15:32:50.741]     }
[15:32:50.741]     ...future.result$conditions <- ...future.conditions
[15:32:50.741]     ...future.result$finished <- base::Sys.time()
[15:32:50.741]     ...future.result
[15:32:50.741] }
[15:32:50.750] Exporting 11 global objects (92.05 KiB) to cluster node #1 ...
[15:32:50.751] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:50.752] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:50.752] Exporting 'x_FUN' (56 bytes) to cluster node #1 ...
[15:32:50.753] Exporting 'x_FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:50.753] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:50.753] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:50.754] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:50.754] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:50.755] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:50.755] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:50.756] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:50.756] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:50.757] Exporting 'valid_types' (176 bytes) to cluster node #1 ...
[15:32:50.757] Exporting 'valid_types' (176 bytes) to cluster node #1 ... DONE
[15:32:50.758] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:50.758] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:50.759] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:50.759] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:50.760] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:50.760] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:50.760] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:50.761] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:50.761] Exporting 11 global objects (92.05 KiB) to cluster node #1 ... DONE
[15:32:50.762] MultisessionFuture started
[15:32:50.762] - Launch lazy future ... done
[15:32:50.763] run() for 'MultisessionFuture' ... done
[15:32:50.763] Created future:
[15:32:50.786] receiveMessageFromWorker() for ClusterFuture ...
[15:32:50.787] - Validating connection of MultisessionFuture
[15:32:50.787] - received message: FutureResult
[15:32:50.787] - Received FutureResult
[15:32:50.787] - Erased future from FutureRegistry
[15:32:50.788] result() for ClusterFuture ...
[15:32:50.788] - result already collected: FutureResult
[15:32:50.788] result() for ClusterFuture ... done
[15:32:50.788] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:50.763] MultisessionFuture:
[15:32:50.763] Label: 'future_vapply-1'
[15:32:50.763] Expression:
[15:32:50.763] {
[15:32:50.763]     do.call(function(...) {
[15:32:50.763]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.763]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.763]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.763]             on.exit(options(oopts), add = TRUE)
[15:32:50.763]         }
[15:32:50.763]         {
[15:32:50.763]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.763]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.763]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.763]             })
[15:32:50.763]         }
[15:32:50.763]     }, args = future.call.arguments)
[15:32:50.763] }
[15:32:50.763] Lazy evaluation: FALSE
[15:32:50.763] Asynchronous evaluation: TRUE
[15:32:50.763] Local evaluation: TRUE
[15:32:50.763] Environment: R_GlobalEnv
[15:32:50.763] Capture standard output: TRUE
[15:32:50.763] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:50.763] Globals: 11 objects totaling 92.11 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 56 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:50.763] Packages: 1 packages ('future.apply')
[15:32:50.763] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:50.763] Resolved: TRUE
[15:32:50.763] Value: <not collected>
[15:32:50.763] Conditions captured: <none>
[15:32:50.763] Early signaling: FALSE
[15:32:50.763] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:50.763] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.789] Chunk #1 of 2 ... DONE
[15:32:50.789] Chunk #2 of 2 ...
[15:32:50.789]  - Finding globals in 'X' for chunk #2 ...
[15:32:50.789] getGlobalsAndPackages() ...
[15:32:50.789] Searching for globals...
[15:32:50.790] 
[15:32:50.790] Searching for globals ... DONE
[15:32:50.790] - globals: [0] <none>
[15:32:50.790] getGlobalsAndPackages() ... DONE
[15:32:50.790]    + additional globals found: [n=0] 
[15:32:50.791]    + additional namespaces needed: [n=0] 
[15:32:50.791]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:50.791]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:50.791]  - seeds: <none>
[15:32:50.791]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.791] getGlobalsAndPackages() ...
[15:32:50.792] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.792] Resolving globals: FALSE
[15:32:50.792] Tweak future expression to call with '...' arguments ...
[15:32:50.792] {
[15:32:50.792]     do.call(function(...) {
[15:32:50.792]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.792]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.792]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.792]             on.exit(options(oopts), add = TRUE)
[15:32:50.792]         }
[15:32:50.792]         {
[15:32:50.792]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.792]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.792]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.792]             })
[15:32:50.792]         }
[15:32:50.792]     }, args = future.call.arguments)
[15:32:50.792] }
[15:32:50.793] Tweak future expression to call with '...' arguments ... DONE
[15:32:50.793] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.794] - packages: [1] 'future.apply'
[15:32:50.794] getGlobalsAndPackages() ... DONE
[15:32:50.794] run() for 'Future' ...
[15:32:50.794] - state: 'created'
[15:32:50.795] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:50.809] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.809] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:50.809]   - Field: 'node'
[15:32:50.810]   - Field: 'label'
[15:32:50.810]   - Field: 'local'
[15:32:50.810]   - Field: 'owner'
[15:32:50.810]   - Field: 'envir'
[15:32:50.810]   - Field: 'workers'
[15:32:50.811]   - Field: 'packages'
[15:32:50.811]   - Field: 'gc'
[15:32:50.811]   - Field: 'conditions'
[15:32:50.811]   - Field: 'persistent'
[15:32:50.811]   - Field: 'expr'
[15:32:50.811]   - Field: 'uuid'
[15:32:50.812]   - Field: 'seed'
[15:32:50.812]   - Field: 'version'
[15:32:50.812]   - Field: 'result'
[15:32:50.812]   - Field: 'asynchronous'
[15:32:50.812]   - Field: 'calls'
[15:32:50.813]   - Field: 'globals'
[15:32:50.813]   - Field: 'stdout'
[15:32:50.813]   - Field: 'earlySignal'
[15:32:50.813]   - Field: 'lazy'
[15:32:50.813]   - Field: 'state'
[15:32:50.813] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:50.814] - Launch lazy future ...
[15:32:50.814] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:50.814] Packages needed by future strategies (n = 0): <none>
[15:32:50.815] {
[15:32:50.815]     {
[15:32:50.815]         {
[15:32:50.815]             ...future.startTime <- base::Sys.time()
[15:32:50.815]             {
[15:32:50.815]                 {
[15:32:50.815]                   {
[15:32:50.815]                     {
[15:32:50.815]                       {
[15:32:50.815]                         base::local({
[15:32:50.815]                           has_future <- base::requireNamespace("future", 
[15:32:50.815]                             quietly = TRUE)
[15:32:50.815]                           if (has_future) {
[15:32:50.815]                             ns <- base::getNamespace("future")
[15:32:50.815]                             version <- ns[[".package"]][["version"]]
[15:32:50.815]                             if (is.null(version)) 
[15:32:50.815]                               version <- utils::packageVersion("future")
[15:32:50.815]                           }
[15:32:50.815]                           else {
[15:32:50.815]                             version <- NULL
[15:32:50.815]                           }
[15:32:50.815]                           if (!has_future || version < "1.8.0") {
[15:32:50.815]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:50.815]                               "", base::R.version$version.string), 
[15:32:50.815]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:50.815]                                 base::R.version$platform, 8 * 
[15:32:50.815]                                   base::.Machine$sizeof.pointer), 
[15:32:50.815]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:50.815]                                 "release", "version")], collapse = " "), 
[15:32:50.815]                               hostname = base::Sys.info()[["nodename"]])
[15:32:50.815]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:50.815]                               info)
[15:32:50.815]                             info <- base::paste(info, collapse = "; ")
[15:32:50.815]                             if (!has_future) {
[15:32:50.815]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:50.815]                                 info)
[15:32:50.815]                             }
[15:32:50.815]                             else {
[15:32:50.815]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:50.815]                                 info, version)
[15:32:50.815]                             }
[15:32:50.815]                             base::stop(msg)
[15:32:50.815]                           }
[15:32:50.815]                         })
[15:32:50.815]                       }
[15:32:50.815]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:50.815]                       base::options(mc.cores = 1L)
[15:32:50.815]                     }
[15:32:50.815]                     base::local({
[15:32:50.815]                       for (pkg in "future.apply") {
[15:32:50.815]                         base::loadNamespace(pkg)
[15:32:50.815]                         base::library(pkg, character.only = TRUE)
[15:32:50.815]                       }
[15:32:50.815]                     })
[15:32:50.815]                   }
[15:32:50.815]                   ...future.strategy.old <- future::plan("list")
[15:32:50.815]                   options(future.plan = NULL)
[15:32:50.815]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.815]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:50.815]                 }
[15:32:50.815]                 ...future.workdir <- getwd()
[15:32:50.815]             }
[15:32:50.815]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:50.815]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:50.815]         }
[15:32:50.815]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:50.815]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:50.815]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:50.815]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:50.815]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:50.815]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:50.815]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:50.815]             base::names(...future.oldOptions))
[15:32:50.815]     }
[15:32:50.815]     if (FALSE) {
[15:32:50.815]     }
[15:32:50.815]     else {
[15:32:50.815]         if (TRUE) {
[15:32:50.815]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:50.815]                 open = "w")
[15:32:50.815]         }
[15:32:50.815]         else {
[15:32:50.815]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:50.815]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:50.815]         }
[15:32:50.815]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:50.815]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:50.815]             base::sink(type = "output", split = FALSE)
[15:32:50.815]             base::close(...future.stdout)
[15:32:50.815]         }, add = TRUE)
[15:32:50.815]     }
[15:32:50.815]     ...future.frame <- base::sys.nframe()
[15:32:50.815]     ...future.conditions <- base::list()
[15:32:50.815]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:50.815]     if (FALSE) {
[15:32:50.815]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:50.815]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:50.815]     }
[15:32:50.815]     ...future.result <- base::tryCatch({
[15:32:50.815]         base::withCallingHandlers({
[15:32:50.815]             ...future.value <- base::withVisible(base::local({
[15:32:50.815]                 ...future.makeSendCondition <- base::local({
[15:32:50.815]                   sendCondition <- NULL
[15:32:50.815]                   function(frame = 1L) {
[15:32:50.815]                     if (is.function(sendCondition)) 
[15:32:50.815]                       return(sendCondition)
[15:32:50.815]                     ns <- getNamespace("parallel")
[15:32:50.815]                     if (exists("sendData", mode = "function", 
[15:32:50.815]                       envir = ns)) {
[15:32:50.815]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:50.815]                         envir = ns)
[15:32:50.815]                       envir <- sys.frame(frame)
[15:32:50.815]                       master <- NULL
[15:32:50.815]                       while (!identical(envir, .GlobalEnv) && 
[15:32:50.815]                         !identical(envir, emptyenv())) {
[15:32:50.815]                         if (exists("master", mode = "list", envir = envir, 
[15:32:50.815]                           inherits = FALSE)) {
[15:32:50.815]                           master <- get("master", mode = "list", 
[15:32:50.815]                             envir = envir, inherits = FALSE)
[15:32:50.815]                           if (inherits(master, c("SOCKnode", 
[15:32:50.815]                             "SOCK0node"))) {
[15:32:50.815]                             sendCondition <<- function(cond) {
[15:32:50.815]                               data <- list(type = "VALUE", value = cond, 
[15:32:50.815]                                 success = TRUE)
[15:32:50.815]                               parallel_sendData(master, data)
[15:32:50.815]                             }
[15:32:50.815]                             return(sendCondition)
[15:32:50.815]                           }
[15:32:50.815]                         }
[15:32:50.815]                         frame <- frame + 1L
[15:32:50.815]                         envir <- sys.frame(frame)
[15:32:50.815]                       }
[15:32:50.815]                     }
[15:32:50.815]                     sendCondition <<- function(cond) NULL
[15:32:50.815]                   }
[15:32:50.815]                 })
[15:32:50.815]                 withCallingHandlers({
[15:32:50.815]                   {
[15:32:50.815]                     do.call(function(...) {
[15:32:50.815]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.815]                       if (!identical(...future.globals.maxSize.org, 
[15:32:50.815]                         ...future.globals.maxSize)) {
[15:32:50.815]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.815]                         on.exit(options(oopts), add = TRUE)
[15:32:50.815]                       }
[15:32:50.815]                       {
[15:32:50.815]                         lapply(seq_along(...future.elements_ii), 
[15:32:50.815]                           FUN = function(jj) {
[15:32:50.815]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.815]                             ...future.FUN(...future.X_jj, ...)
[15:32:50.815]                           })
[15:32:50.815]                       }
[15:32:50.815]                     }, args = future.call.arguments)
[15:32:50.815]                   }
[15:32:50.815]                 }, immediateCondition = function(cond) {
[15:32:50.815]                   sendCondition <- ...future.makeSendCondition()
[15:32:50.815]                   sendCondition(cond)
[15:32:50.815]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.815]                   {
[15:32:50.815]                     inherits <- base::inherits
[15:32:50.815]                     invokeRestart <- base::invokeRestart
[15:32:50.815]                     is.null <- base::is.null
[15:32:50.815]                     muffled <- FALSE
[15:32:50.815]                     if (inherits(cond, "message")) {
[15:32:50.815]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:50.815]                       if (muffled) 
[15:32:50.815]                         invokeRestart("muffleMessage")
[15:32:50.815]                     }
[15:32:50.815]                     else if (inherits(cond, "warning")) {
[15:32:50.815]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:50.815]                       if (muffled) 
[15:32:50.815]                         invokeRestart("muffleWarning")
[15:32:50.815]                     }
[15:32:50.815]                     else if (inherits(cond, "condition")) {
[15:32:50.815]                       if (!is.null(pattern)) {
[15:32:50.815]                         computeRestarts <- base::computeRestarts
[15:32:50.815]                         grepl <- base::grepl
[15:32:50.815]                         restarts <- computeRestarts(cond)
[15:32:50.815]                         for (restart in restarts) {
[15:32:50.815]                           name <- restart$name
[15:32:50.815]                           if (is.null(name)) 
[15:32:50.815]                             next
[15:32:50.815]                           if (!grepl(pattern, name)) 
[15:32:50.815]                             next
[15:32:50.815]                           invokeRestart(restart)
[15:32:50.815]                           muffled <- TRUE
[15:32:50.815]                           break
[15:32:50.815]                         }
[15:32:50.815]                       }
[15:32:50.815]                     }
[15:32:50.815]                     invisible(muffled)
[15:32:50.815]                   }
[15:32:50.815]                   muffleCondition(cond)
[15:32:50.815]                 })
[15:32:50.815]             }))
[15:32:50.815]             future::FutureResult(value = ...future.value$value, 
[15:32:50.815]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.815]                   ...future.rng), globalenv = if (FALSE) 
[15:32:50.815]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:50.815]                     ...future.globalenv.names))
[15:32:50.815]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:50.815]         }, condition = base::local({
[15:32:50.815]             c <- base::c
[15:32:50.815]             inherits <- base::inherits
[15:32:50.815]             invokeRestart <- base::invokeRestart
[15:32:50.815]             length <- base::length
[15:32:50.815]             list <- base::list
[15:32:50.815]             seq.int <- base::seq.int
[15:32:50.815]             signalCondition <- base::signalCondition
[15:32:50.815]             sys.calls <- base::sys.calls
[15:32:50.815]             `[[` <- base::`[[`
[15:32:50.815]             `+` <- base::`+`
[15:32:50.815]             `<<-` <- base::`<<-`
[15:32:50.815]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:50.815]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:50.815]                   3L)]
[15:32:50.815]             }
[15:32:50.815]             function(cond) {
[15:32:50.815]                 is_error <- inherits(cond, "error")
[15:32:50.815]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:50.815]                   NULL)
[15:32:50.815]                 if (is_error) {
[15:32:50.815]                   sessionInformation <- function() {
[15:32:50.815]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:50.815]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:50.815]                       search = base::search(), system = base::Sys.info())
[15:32:50.815]                   }
[15:32:50.815]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.815]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:50.815]                     cond$call), session = sessionInformation(), 
[15:32:50.815]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:50.815]                   signalCondition(cond)
[15:32:50.815]                 }
[15:32:50.815]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:50.815]                 "immediateCondition"))) {
[15:32:50.815]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:50.815]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.815]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:50.815]                   if (TRUE && !signal) {
[15:32:50.815]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.815]                     {
[15:32:50.815]                       inherits <- base::inherits
[15:32:50.815]                       invokeRestart <- base::invokeRestart
[15:32:50.815]                       is.null <- base::is.null
[15:32:50.815]                       muffled <- FALSE
[15:32:50.815]                       if (inherits(cond, "message")) {
[15:32:50.815]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.815]                         if (muffled) 
[15:32:50.815]                           invokeRestart("muffleMessage")
[15:32:50.815]                       }
[15:32:50.815]                       else if (inherits(cond, "warning")) {
[15:32:50.815]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.815]                         if (muffled) 
[15:32:50.815]                           invokeRestart("muffleWarning")
[15:32:50.815]                       }
[15:32:50.815]                       else if (inherits(cond, "condition")) {
[15:32:50.815]                         if (!is.null(pattern)) {
[15:32:50.815]                           computeRestarts <- base::computeRestarts
[15:32:50.815]                           grepl <- base::grepl
[15:32:50.815]                           restarts <- computeRestarts(cond)
[15:32:50.815]                           for (restart in restarts) {
[15:32:50.815]                             name <- restart$name
[15:32:50.815]                             if (is.null(name)) 
[15:32:50.815]                               next
[15:32:50.815]                             if (!grepl(pattern, name)) 
[15:32:50.815]                               next
[15:32:50.815]                             invokeRestart(restart)
[15:32:50.815]                             muffled <- TRUE
[15:32:50.815]                             break
[15:32:50.815]                           }
[15:32:50.815]                         }
[15:32:50.815]                       }
[15:32:50.815]                       invisible(muffled)
[15:32:50.815]                     }
[15:32:50.815]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.815]                   }
[15:32:50.815]                 }
[15:32:50.815]                 else {
[15:32:50.815]                   if (TRUE) {
[15:32:50.815]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.815]                     {
[15:32:50.815]                       inherits <- base::inherits
[15:32:50.815]                       invokeRestart <- base::invokeRestart
[15:32:50.815]                       is.null <- base::is.null
[15:32:50.815]                       muffled <- FALSE
[15:32:50.815]                       if (inherits(cond, "message")) {
[15:32:50.815]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.815]                         if (muffled) 
[15:32:50.815]                           invokeRestart("muffleMessage")
[15:32:50.815]                       }
[15:32:50.815]                       else if (inherits(cond, "warning")) {
[15:32:50.815]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.815]                         if (muffled) 
[15:32:50.815]                           invokeRestart("muffleWarning")
[15:32:50.815]                       }
[15:32:50.815]                       else if (inherits(cond, "condition")) {
[15:32:50.815]                         if (!is.null(pattern)) {
[15:32:50.815]                           computeRestarts <- base::computeRestarts
[15:32:50.815]                           grepl <- base::grepl
[15:32:50.815]                           restarts <- computeRestarts(cond)
[15:32:50.815]                           for (restart in restarts) {
[15:32:50.815]                             name <- restart$name
[15:32:50.815]                             if (is.null(name)) 
[15:32:50.815]                               next
[15:32:50.815]                             if (!grepl(pattern, name)) 
[15:32:50.815]                               next
[15:32:50.815]                             invokeRestart(restart)
[15:32:50.815]                             muffled <- TRUE
[15:32:50.815]                             break
[15:32:50.815]                           }
[15:32:50.815]                         }
[15:32:50.815]                       }
[15:32:50.815]                       invisible(muffled)
[15:32:50.815]                     }
[15:32:50.815]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.815]                   }
[15:32:50.815]                 }
[15:32:50.815]             }
[15:32:50.815]         }))
[15:32:50.815]     }, error = function(ex) {
[15:32:50.815]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:50.815]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.815]                 ...future.rng), started = ...future.startTime, 
[15:32:50.815]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:50.815]             version = "1.8"), class = "FutureResult")
[15:32:50.815]     }, finally = {
[15:32:50.815]         if (!identical(...future.workdir, getwd())) 
[15:32:50.815]             setwd(...future.workdir)
[15:32:50.815]         {
[15:32:50.815]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:50.815]                 ...future.oldOptions$nwarnings <- NULL
[15:32:50.815]             }
[15:32:50.815]             base::options(...future.oldOptions)
[15:32:50.815]             if (.Platform$OS.type == "windows") {
[15:32:50.815]                 old_names <- names(...future.oldEnvVars)
[15:32:50.815]                 envs <- base::Sys.getenv()
[15:32:50.815]                 names <- names(envs)
[15:32:50.815]                 common <- intersect(names, old_names)
[15:32:50.815]                 added <- setdiff(names, old_names)
[15:32:50.815]                 removed <- setdiff(old_names, names)
[15:32:50.815]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:50.815]                   envs[common]]
[15:32:50.815]                 NAMES <- toupper(changed)
[15:32:50.815]                 args <- list()
[15:32:50.815]                 for (kk in seq_along(NAMES)) {
[15:32:50.815]                   name <- changed[[kk]]
[15:32:50.815]                   NAME <- NAMES[[kk]]
[15:32:50.815]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.815]                     next
[15:32:50.815]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.815]                 }
[15:32:50.815]                 NAMES <- toupper(added)
[15:32:50.815]                 for (kk in seq_along(NAMES)) {
[15:32:50.815]                   name <- added[[kk]]
[15:32:50.815]                   NAME <- NAMES[[kk]]
[15:32:50.815]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.815]                     next
[15:32:50.815]                   args[[name]] <- ""
[15:32:50.815]                 }
[15:32:50.815]                 NAMES <- toupper(removed)
[15:32:50.815]                 for (kk in seq_along(NAMES)) {
[15:32:50.815]                   name <- removed[[kk]]
[15:32:50.815]                   NAME <- NAMES[[kk]]
[15:32:50.815]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.815]                     next
[15:32:50.815]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.815]                 }
[15:32:50.815]                 if (length(args) > 0) 
[15:32:50.815]                   base::do.call(base::Sys.setenv, args = args)
[15:32:50.815]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:50.815]             }
[15:32:50.815]             else {
[15:32:50.815]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:50.815]             }
[15:32:50.815]             {
[15:32:50.815]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:50.815]                   0L) {
[15:32:50.815]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:50.815]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:50.815]                   base::options(opts)
[15:32:50.815]                 }
[15:32:50.815]                 {
[15:32:50.815]                   {
[15:32:50.815]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:50.815]                     NULL
[15:32:50.815]                   }
[15:32:50.815]                   options(future.plan = NULL)
[15:32:50.815]                   if (is.na(NA_character_)) 
[15:32:50.815]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.815]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:50.815]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:50.815]                     .init = FALSE)
[15:32:50.815]                 }
[15:32:50.815]             }
[15:32:50.815]         }
[15:32:50.815]     })
[15:32:50.815]     if (TRUE) {
[15:32:50.815]         base::sink(type = "output", split = FALSE)
[15:32:50.815]         if (TRUE) {
[15:32:50.815]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:50.815]         }
[15:32:50.815]         else {
[15:32:50.815]             ...future.result["stdout"] <- base::list(NULL)
[15:32:50.815]         }
[15:32:50.815]         base::close(...future.stdout)
[15:32:50.815]         ...future.stdout <- NULL
[15:32:50.815]     }
[15:32:50.815]     ...future.result$conditions <- ...future.conditions
[15:32:50.815]     ...future.result$finished <- base::Sys.time()
[15:32:50.815]     ...future.result
[15:32:50.815] }
[15:32:50.820] Exporting 11 global objects (92.05 KiB) to cluster node #1 ...
[15:32:50.821] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:50.821] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:50.822] Exporting 'x_FUN' (56 bytes) to cluster node #1 ...
[15:32:50.822] Exporting 'x_FUN' (56 bytes) to cluster node #1 ... DONE
[15:32:50.822] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:50.823] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:50.823] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:50.824] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:50.824] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:50.824] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:50.824] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:50.825] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:50.825] Exporting 'valid_types' (176 bytes) to cluster node #1 ...
[15:32:50.826] Exporting 'valid_types' (176 bytes) to cluster node #1 ... DONE
[15:32:50.826] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:50.826] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:50.826] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:50.827] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:50.827] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:50.828] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:50.828] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:50.829] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:50.829] Exporting 11 global objects (92.05 KiB) to cluster node #1 ... DONE
[15:32:50.830] MultisessionFuture started
[15:32:50.830] - Launch lazy future ... done
[15:32:50.830] run() for 'MultisessionFuture' ... done
[15:32:50.831] Created future:
[15:32:50.849] receiveMessageFromWorker() for ClusterFuture ...
[15:32:50.849] - Validating connection of MultisessionFuture
[15:32:50.850] - received message: FutureResult
[15:32:50.850] - Received FutureResult
[15:32:50.850] - Erased future from FutureRegistry
[15:32:50.850] result() for ClusterFuture ...
[15:32:50.850] - result already collected: FutureResult
[15:32:50.851] result() for ClusterFuture ... done
[15:32:50.851] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:50.831] MultisessionFuture:
[15:32:50.831] Label: 'future_vapply-2'
[15:32:50.831] Expression:
[15:32:50.831] {
[15:32:50.831]     do.call(function(...) {
[15:32:50.831]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.831]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.831]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.831]             on.exit(options(oopts), add = TRUE)
[15:32:50.831]         }
[15:32:50.831]         {
[15:32:50.831]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.831]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.831]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.831]             })
[15:32:50.831]         }
[15:32:50.831]     }, args = future.call.arguments)
[15:32:50.831] }
[15:32:50.831] Lazy evaluation: FALSE
[15:32:50.831] Asynchronous evaluation: TRUE
[15:32:50.831] Local evaluation: TRUE
[15:32:50.831] Environment: R_GlobalEnv
[15:32:50.831] Capture standard output: TRUE
[15:32:50.831] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:50.831] Globals: 11 objects totaling 92.16 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 56 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:50.831] Packages: 1 packages ('future.apply')
[15:32:50.831] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:50.831] Resolved: TRUE
[15:32:50.831] Value: <not collected>
[15:32:50.831] Conditions captured: <none>
[15:32:50.831] Early signaling: FALSE
[15:32:50.831] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:50.831] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.851] Chunk #2 of 2 ... DONE
[15:32:50.852] Launching 2 futures (chunks) ... DONE
[15:32:50.852] Resolving 2 futures (chunks) ...
[15:32:50.852] resolve() on list ...
[15:32:50.852]  recursive: 0
[15:32:50.852]  length: 2
[15:32:50.852] 
[15:32:50.853] Future #1
[15:32:50.853] result() for ClusterFuture ...
[15:32:50.853] - result already collected: FutureResult
[15:32:50.853] result() for ClusterFuture ... done
[15:32:50.853] result() for ClusterFuture ...
[15:32:50.853] - result already collected: FutureResult
[15:32:50.854] result() for ClusterFuture ... done
[15:32:50.854] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:50.854] - nx: 2
[15:32:50.854] - relay: TRUE
[15:32:50.854] - stdout: TRUE
[15:32:50.854] - signal: TRUE
[15:32:50.855] - resignal: FALSE
[15:32:50.855] - force: TRUE
[15:32:50.855] - relayed: [n=2] FALSE, FALSE
[15:32:50.855] - queued futures: [n=2] FALSE, FALSE
[15:32:50.855]  - until=1
[15:32:50.855]  - relaying element #1
[15:32:50.856] result() for ClusterFuture ...
[15:32:50.856] - result already collected: FutureResult
[15:32:50.856] result() for ClusterFuture ... done
[15:32:50.856] result() for ClusterFuture ...
[15:32:50.856] - result already collected: FutureResult
[15:32:50.856] result() for ClusterFuture ... done
[15:32:50.857] result() for ClusterFuture ...
[15:32:50.857] - result already collected: FutureResult
[15:32:50.857] result() for ClusterFuture ... done
[15:32:50.857] result() for ClusterFuture ...
[15:32:50.857] - result already collected: FutureResult
[15:32:50.857] result() for ClusterFuture ... done
[15:32:50.858] - relayed: [n=2] TRUE, FALSE
[15:32:50.858] - queued futures: [n=2] TRUE, FALSE
[15:32:50.858] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:50.858]  length: 1 (resolved future 1)
[15:32:50.858] Future #2
[15:32:50.859] result() for ClusterFuture ...
[15:32:50.859] - result already collected: FutureResult
[15:32:50.859] result() for ClusterFuture ... done
[15:32:50.859] result() for ClusterFuture ...
[15:32:50.859] - result already collected: FutureResult
[15:32:50.860] result() for ClusterFuture ... done
[15:32:50.860] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:32:50.860] - nx: 2
[15:32:50.861] - relay: TRUE
[15:32:50.861] - stdout: TRUE
[15:32:50.861] - signal: TRUE
[15:32:50.862] - resignal: FALSE
[15:32:50.862] - force: TRUE
[15:32:50.862] - relayed: [n=2] TRUE, FALSE
[15:32:50.862] - queued futures: [n=2] TRUE, FALSE
[15:32:50.863]  - until=2
[15:32:50.863]  - relaying element #2
[15:32:50.863] result() for ClusterFuture ...
[15:32:50.863] - result already collected: FutureResult
[15:32:50.864] result() for ClusterFuture ... done
[15:32:50.864] result() for ClusterFuture ...
[15:32:50.864] - result already collected: FutureResult
[15:32:50.864] result() for ClusterFuture ... done
[15:32:50.865] result() for ClusterFuture ...
[15:32:50.865] - result already collected: FutureResult
[15:32:50.865] result() for ClusterFuture ... done
[15:32:50.866] result() for ClusterFuture ...
[15:32:50.866] - result already collected: FutureResult
[15:32:50.866] result() for ClusterFuture ... done
[15:32:50.867] - relayed: [n=2] TRUE, TRUE
[15:32:50.867] - queued futures: [n=2] TRUE, TRUE
[15:32:50.867] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:32:50.868]  length: 0 (resolved future 2)
[15:32:50.868] Relaying remaining futures
[15:32:50.868] signalConditionsASAP(NULL, pos=0) ...
[15:32:50.868] - nx: 2
[15:32:50.869] - relay: TRUE
[15:32:50.869] - stdout: TRUE
[15:32:50.869] - signal: TRUE
[15:32:50.870] - resignal: FALSE
[15:32:50.870] - force: TRUE
[15:32:50.870] - relayed: [n=2] TRUE, TRUE
[15:32:50.870] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:32:50.871] - relayed: [n=2] TRUE, TRUE
[15:32:50.871] - queued futures: [n=2] TRUE, TRUE
[15:32:50.872] signalConditionsASAP(NULL, pos=0) ... done
[15:32:50.872] resolve() on list ... DONE
[15:32:50.872] result() for ClusterFuture ...
[15:32:50.872] - result already collected: FutureResult
[15:32:50.873] result() for ClusterFuture ... done
[15:32:50.873] result() for ClusterFuture ...
[15:32:50.873] - result already collected: FutureResult
[15:32:50.873] result() for ClusterFuture ... done
[15:32:50.874] result() for ClusterFuture ...
[15:32:50.874] - result already collected: FutureResult
[15:32:50.874] result() for ClusterFuture ... done
[15:32:50.875] result() for ClusterFuture ...
[15:32:50.875] - result already collected: FutureResult
[15:32:50.875] result() for ClusterFuture ... done
[15:32:50.876]  - Number of value chunks collected: 2
[15:32:50.876] Resolving 2 futures (chunks) ... DONE
[15:32:50.876] Reducing values from 2 chunks ...
[15:32:50.876]  - Number of values collected after concatenation: 3
[15:32:50.877]  - Number of values expected: 3
[15:32:50.877] Reducing values from 2 chunks ... DONE
[15:32:50.877] future_lapply() ... DONE
- exceptions ...
[15:32:50.878] future_lapply() ...
[15:32:50.886] Number of chunks: 2
[15:32:50.886] getGlobalsAndPackagesXApply() ...
[15:32:50.887]  - future.globals: TRUE
[15:32:50.887] getGlobalsAndPackages() ...
[15:32:50.887] Searching for globals...
[15:32:50.892] - globals found: [16] 'FUN', '{', '<-', 'x_FUN', 'if', '!=', 'length', 'times', 'stopf', 'stop_if_not', 'all', '==', 'dim', '%in%', 'typeof', 'valid_types'
[15:32:50.892] Searching for globals ... DONE
[15:32:50.892] Resolving globals: FALSE
[15:32:50.893] The total size of the 7 globals is 92.90 KiB (95128 bytes)
[15:32:50.894] The total size of the 7 globals exported for future expression ('FUN()') is 92.90 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'stop_if_not' (44.12 KiB of class 'function'), 'stopf' (26.43 KiB of class 'function') and 'FUN' (21.22 KiB of class 'function')
[15:32:50.894] - globals: [7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:50.894] - packages: [1] 'future.apply'
[15:32:50.894] getGlobalsAndPackages() ... DONE
[15:32:50.895]  - globals found/used: [n=7] 'FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types'
[15:32:50.895]  - needed namespaces: [n=1] 'future.apply'
[15:32:50.895] Finding globals ... DONE
[15:32:50.895]  - use_args: TRUE
[15:32:50.895]  - Getting '...' globals ...
[15:32:50.896] resolve() on list ...
[15:32:50.896]  recursive: 0
[15:32:50.896]  length: 1
[15:32:50.897]  elements: '...'
[15:32:50.897]  length: 0 (resolved future 1)
[15:32:50.897] resolve() on list ... DONE
[15:32:50.898]    - '...' content: [n=0] 
[15:32:50.898] List of 1
[15:32:50.898]  $ ...: list()
[15:32:50.898]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:50.898]  - attr(*, "where")=List of 1
[15:32:50.898]   ..$ ...:<environment: 0x0000022d41166258> 
[15:32:50.898]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:50.898]  - attr(*, "resolved")= logi TRUE
[15:32:50.898]  - attr(*, "total_size")= num NA
[15:32:50.902]  - Getting '...' globals ... DONE
[15:32:50.903] Globals to be used in all futures (chunks): [n=8] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...'
[15:32:50.903] List of 8
[15:32:50.903]  $ ...future.FUN:function (x, ...)  
[15:32:50.903]  $ x_FUN        :function (x)  
[15:32:50.903]  $ times        : int 2
[15:32:50.903]  $ stopf        :function (fmt, ..., call. = TRUE, domain = NULL)  
[15:32:50.903]  $ stop_if_not  :function (...)  
[15:32:50.903]  $ dim          : NULL
[15:32:50.903]  $ valid_types  : chr [1:3] "logical" "integer" "double"
[15:32:50.903]  $ ...          : list()
[15:32:50.903]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:32:50.903]  - attr(*, "where")=List of 8
[15:32:50.903]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:32:50.903]   ..$ x_FUN        :<environment: R_EmptyEnv> 
[15:32:50.903]   ..$ times        :<environment: R_EmptyEnv> 
[15:32:50.903]   ..$ stopf        :<environment: R_EmptyEnv> 
[15:32:50.903]   ..$ stop_if_not  :<environment: R_EmptyEnv> 
[15:32:50.903]   ..$ dim          :<environment: R_EmptyEnv> 
[15:32:50.903]   ..$ valid_types  :<environment: R_EmptyEnv> 
[15:32:50.903]   ..$ ...          :<environment: 0x0000022d41166258> 
[15:32:50.903]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:32:50.903]  - attr(*, "resolved")= logi FALSE
[15:32:50.903]  - attr(*, "total_size")= num 95128
[15:32:50.913] Packages to be attached in all futures: [n=1] 'future.apply'
[15:32:50.914] getGlobalsAndPackagesXApply() ... DONE
[15:32:50.914] Number of futures (= number of chunks): 2
[15:32:50.915] Launching 2 futures (chunks) ...
[15:32:50.915] Chunk #1 of 2 ...
[15:32:50.915]  - Finding globals in 'X' for chunk #1 ...
[15:32:50.915] getGlobalsAndPackages() ...
[15:32:50.916] Searching for globals...
[15:32:50.916] 
[15:32:50.917] Searching for globals ... DONE
[15:32:50.917] - globals: [0] <none>
[15:32:50.917] getGlobalsAndPackages() ... DONE
[15:32:50.917]    + additional globals found: [n=0] 
[15:32:50.918]    + additional namespaces needed: [n=0] 
[15:32:50.918]  - Finding globals in 'X' for chunk #1 ... DONE
[15:32:50.918]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:50.918]  - seeds: <none>
[15:32:50.919]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.919] getGlobalsAndPackages() ...
[15:32:50.919] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.919] Resolving globals: FALSE
[15:32:50.920] Tweak future expression to call with '...' arguments ...
[15:32:50.920] {
[15:32:50.920]     do.call(function(...) {
[15:32:50.920]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.920]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.920]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.920]             on.exit(options(oopts), add = TRUE)
[15:32:50.920]         }
[15:32:50.920]         {
[15:32:50.920]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.920]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.920]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.920]             })
[15:32:50.920]         }
[15:32:50.920]     }, args = future.call.arguments)
[15:32:50.920] }
[15:32:50.921] Tweak future expression to call with '...' arguments ... DONE
[15:32:50.922] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:50.922] - packages: [1] 'future.apply'
[15:32:50.922] getGlobalsAndPackages() ... DONE
[15:32:50.923] run() for 'Future' ...
[15:32:50.923] - state: 'created'
[15:32:50.924] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:50.942] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:50.943] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:50.943]   - Field: 'node'
[15:32:50.944]   - Field: 'label'
[15:32:50.944]   - Field: 'local'
[15:32:50.944]   - Field: 'owner'
[15:32:50.944]   - Field: 'envir'
[15:32:50.945]   - Field: 'workers'
[15:32:50.945]   - Field: 'packages'
[15:32:50.945]   - Field: 'gc'
[15:32:50.946]   - Field: 'conditions'
[15:32:50.946]   - Field: 'persistent'
[15:32:50.946]   - Field: 'expr'
[15:32:50.947]   - Field: 'uuid'
[15:32:50.947]   - Field: 'seed'
[15:32:50.947]   - Field: 'version'
[15:32:50.947]   - Field: 'result'
[15:32:50.948]   - Field: 'asynchronous'
[15:32:50.948]   - Field: 'calls'
[15:32:50.948]   - Field: 'globals'
[15:32:50.948]   - Field: 'stdout'
[15:32:50.949]   - Field: 'earlySignal'
[15:32:50.949]   - Field: 'lazy'
[15:32:50.949]   - Field: 'state'
[15:32:50.950] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:50.950] - Launch lazy future ...
[15:32:50.950] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:50.951] Packages needed by future strategies (n = 0): <none>
[15:32:50.952] {
[15:32:50.952]     {
[15:32:50.952]         {
[15:32:50.952]             ...future.startTime <- base::Sys.time()
[15:32:50.952]             {
[15:32:50.952]                 {
[15:32:50.952]                   {
[15:32:50.952]                     {
[15:32:50.952]                       {
[15:32:50.952]                         base::local({
[15:32:50.952]                           has_future <- base::requireNamespace("future", 
[15:32:50.952]                             quietly = TRUE)
[15:32:50.952]                           if (has_future) {
[15:32:50.952]                             ns <- base::getNamespace("future")
[15:32:50.952]                             version <- ns[[".package"]][["version"]]
[15:32:50.952]                             if (is.null(version)) 
[15:32:50.952]                               version <- utils::packageVersion("future")
[15:32:50.952]                           }
[15:32:50.952]                           else {
[15:32:50.952]                             version <- NULL
[15:32:50.952]                           }
[15:32:50.952]                           if (!has_future || version < "1.8.0") {
[15:32:50.952]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:50.952]                               "", base::R.version$version.string), 
[15:32:50.952]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:50.952]                                 base::R.version$platform, 8 * 
[15:32:50.952]                                   base::.Machine$sizeof.pointer), 
[15:32:50.952]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:50.952]                                 "release", "version")], collapse = " "), 
[15:32:50.952]                               hostname = base::Sys.info()[["nodename"]])
[15:32:50.952]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:50.952]                               info)
[15:32:50.952]                             info <- base::paste(info, collapse = "; ")
[15:32:50.952]                             if (!has_future) {
[15:32:50.952]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:50.952]                                 info)
[15:32:50.952]                             }
[15:32:50.952]                             else {
[15:32:50.952]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:50.952]                                 info, version)
[15:32:50.952]                             }
[15:32:50.952]                             base::stop(msg)
[15:32:50.952]                           }
[15:32:50.952]                         })
[15:32:50.952]                       }
[15:32:50.952]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:50.952]                       base::options(mc.cores = 1L)
[15:32:50.952]                     }
[15:32:50.952]                     base::local({
[15:32:50.952]                       for (pkg in "future.apply") {
[15:32:50.952]                         base::loadNamespace(pkg)
[15:32:50.952]                         base::library(pkg, character.only = TRUE)
[15:32:50.952]                       }
[15:32:50.952]                     })
[15:32:50.952]                   }
[15:32:50.952]                   ...future.strategy.old <- future::plan("list")
[15:32:50.952]                   options(future.plan = NULL)
[15:32:50.952]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.952]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:50.952]                 }
[15:32:50.952]                 ...future.workdir <- getwd()
[15:32:50.952]             }
[15:32:50.952]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:50.952]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:50.952]         }
[15:32:50.952]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:50.952]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:50.952]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:50.952]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:50.952]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:50.952]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:50.952]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:50.952]             base::names(...future.oldOptions))
[15:32:50.952]     }
[15:32:50.952]     if (FALSE) {
[15:32:50.952]     }
[15:32:50.952]     else {
[15:32:50.952]         if (TRUE) {
[15:32:50.952]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:50.952]                 open = "w")
[15:32:50.952]         }
[15:32:50.952]         else {
[15:32:50.952]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:50.952]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:50.952]         }
[15:32:50.952]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:50.952]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:50.952]             base::sink(type = "output", split = FALSE)
[15:32:50.952]             base::close(...future.stdout)
[15:32:50.952]         }, add = TRUE)
[15:32:50.952]     }
[15:32:50.952]     ...future.frame <- base::sys.nframe()
[15:32:50.952]     ...future.conditions <- base::list()
[15:32:50.952]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:50.952]     if (FALSE) {
[15:32:50.952]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:50.952]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:50.952]     }
[15:32:50.952]     ...future.result <- base::tryCatch({
[15:32:50.952]         base::withCallingHandlers({
[15:32:50.952]             ...future.value <- base::withVisible(base::local({
[15:32:50.952]                 ...future.makeSendCondition <- base::local({
[15:32:50.952]                   sendCondition <- NULL
[15:32:50.952]                   function(frame = 1L) {
[15:32:50.952]                     if (is.function(sendCondition)) 
[15:32:50.952]                       return(sendCondition)
[15:32:50.952]                     ns <- getNamespace("parallel")
[15:32:50.952]                     if (exists("sendData", mode = "function", 
[15:32:50.952]                       envir = ns)) {
[15:32:50.952]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:50.952]                         envir = ns)
[15:32:50.952]                       envir <- sys.frame(frame)
[15:32:50.952]                       master <- NULL
[15:32:50.952]                       while (!identical(envir, .GlobalEnv) && 
[15:32:50.952]                         !identical(envir, emptyenv())) {
[15:32:50.952]                         if (exists("master", mode = "list", envir = envir, 
[15:32:50.952]                           inherits = FALSE)) {
[15:32:50.952]                           master <- get("master", mode = "list", 
[15:32:50.952]                             envir = envir, inherits = FALSE)
[15:32:50.952]                           if (inherits(master, c("SOCKnode", 
[15:32:50.952]                             "SOCK0node"))) {
[15:32:50.952]                             sendCondition <<- function(cond) {
[15:32:50.952]                               data <- list(type = "VALUE", value = cond, 
[15:32:50.952]                                 success = TRUE)
[15:32:50.952]                               parallel_sendData(master, data)
[15:32:50.952]                             }
[15:32:50.952]                             return(sendCondition)
[15:32:50.952]                           }
[15:32:50.952]                         }
[15:32:50.952]                         frame <- frame + 1L
[15:32:50.952]                         envir <- sys.frame(frame)
[15:32:50.952]                       }
[15:32:50.952]                     }
[15:32:50.952]                     sendCondition <<- function(cond) NULL
[15:32:50.952]                   }
[15:32:50.952]                 })
[15:32:50.952]                 withCallingHandlers({
[15:32:50.952]                   {
[15:32:50.952]                     do.call(function(...) {
[15:32:50.952]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.952]                       if (!identical(...future.globals.maxSize.org, 
[15:32:50.952]                         ...future.globals.maxSize)) {
[15:32:50.952]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.952]                         on.exit(options(oopts), add = TRUE)
[15:32:50.952]                       }
[15:32:50.952]                       {
[15:32:50.952]                         lapply(seq_along(...future.elements_ii), 
[15:32:50.952]                           FUN = function(jj) {
[15:32:50.952]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.952]                             ...future.FUN(...future.X_jj, ...)
[15:32:50.952]                           })
[15:32:50.952]                       }
[15:32:50.952]                     }, args = future.call.arguments)
[15:32:50.952]                   }
[15:32:50.952]                 }, immediateCondition = function(cond) {
[15:32:50.952]                   sendCondition <- ...future.makeSendCondition()
[15:32:50.952]                   sendCondition(cond)
[15:32:50.952]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.952]                   {
[15:32:50.952]                     inherits <- base::inherits
[15:32:50.952]                     invokeRestart <- base::invokeRestart
[15:32:50.952]                     is.null <- base::is.null
[15:32:50.952]                     muffled <- FALSE
[15:32:50.952]                     if (inherits(cond, "message")) {
[15:32:50.952]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:50.952]                       if (muffled) 
[15:32:50.952]                         invokeRestart("muffleMessage")
[15:32:50.952]                     }
[15:32:50.952]                     else if (inherits(cond, "warning")) {
[15:32:50.952]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:50.952]                       if (muffled) 
[15:32:50.952]                         invokeRestart("muffleWarning")
[15:32:50.952]                     }
[15:32:50.952]                     else if (inherits(cond, "condition")) {
[15:32:50.952]                       if (!is.null(pattern)) {
[15:32:50.952]                         computeRestarts <- base::computeRestarts
[15:32:50.952]                         grepl <- base::grepl
[15:32:50.952]                         restarts <- computeRestarts(cond)
[15:32:50.952]                         for (restart in restarts) {
[15:32:50.952]                           name <- restart$name
[15:32:50.952]                           if (is.null(name)) 
[15:32:50.952]                             next
[15:32:50.952]                           if (!grepl(pattern, name)) 
[15:32:50.952]                             next
[15:32:50.952]                           invokeRestart(restart)
[15:32:50.952]                           muffled <- TRUE
[15:32:50.952]                           break
[15:32:50.952]                         }
[15:32:50.952]                       }
[15:32:50.952]                     }
[15:32:50.952]                     invisible(muffled)
[15:32:50.952]                   }
[15:32:50.952]                   muffleCondition(cond)
[15:32:50.952]                 })
[15:32:50.952]             }))
[15:32:50.952]             future::FutureResult(value = ...future.value$value, 
[15:32:50.952]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.952]                   ...future.rng), globalenv = if (FALSE) 
[15:32:50.952]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:50.952]                     ...future.globalenv.names))
[15:32:50.952]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:50.952]         }, condition = base::local({
[15:32:50.952]             c <- base::c
[15:32:50.952]             inherits <- base::inherits
[15:32:50.952]             invokeRestart <- base::invokeRestart
[15:32:50.952]             length <- base::length
[15:32:50.952]             list <- base::list
[15:32:50.952]             seq.int <- base::seq.int
[15:32:50.952]             signalCondition <- base::signalCondition
[15:32:50.952]             sys.calls <- base::sys.calls
[15:32:50.952]             `[[` <- base::`[[`
[15:32:50.952]             `+` <- base::`+`
[15:32:50.952]             `<<-` <- base::`<<-`
[15:32:50.952]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:50.952]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:50.952]                   3L)]
[15:32:50.952]             }
[15:32:50.952]             function(cond) {
[15:32:50.952]                 is_error <- inherits(cond, "error")
[15:32:50.952]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:50.952]                   NULL)
[15:32:50.952]                 if (is_error) {
[15:32:50.952]                   sessionInformation <- function() {
[15:32:50.952]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:50.952]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:50.952]                       search = base::search(), system = base::Sys.info())
[15:32:50.952]                   }
[15:32:50.952]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.952]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:50.952]                     cond$call), session = sessionInformation(), 
[15:32:50.952]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:50.952]                   signalCondition(cond)
[15:32:50.952]                 }
[15:32:50.952]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:50.952]                 "immediateCondition"))) {
[15:32:50.952]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:50.952]                   ...future.conditions[[length(...future.conditions) + 
[15:32:50.952]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:50.952]                   if (TRUE && !signal) {
[15:32:50.952]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.952]                     {
[15:32:50.952]                       inherits <- base::inherits
[15:32:50.952]                       invokeRestart <- base::invokeRestart
[15:32:50.952]                       is.null <- base::is.null
[15:32:50.952]                       muffled <- FALSE
[15:32:50.952]                       if (inherits(cond, "message")) {
[15:32:50.952]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.952]                         if (muffled) 
[15:32:50.952]                           invokeRestart("muffleMessage")
[15:32:50.952]                       }
[15:32:50.952]                       else if (inherits(cond, "warning")) {
[15:32:50.952]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.952]                         if (muffled) 
[15:32:50.952]                           invokeRestart("muffleWarning")
[15:32:50.952]                       }
[15:32:50.952]                       else if (inherits(cond, "condition")) {
[15:32:50.952]                         if (!is.null(pattern)) {
[15:32:50.952]                           computeRestarts <- base::computeRestarts
[15:32:50.952]                           grepl <- base::grepl
[15:32:50.952]                           restarts <- computeRestarts(cond)
[15:32:50.952]                           for (restart in restarts) {
[15:32:50.952]                             name <- restart$name
[15:32:50.952]                             if (is.null(name)) 
[15:32:50.952]                               next
[15:32:50.952]                             if (!grepl(pattern, name)) 
[15:32:50.952]                               next
[15:32:50.952]                             invokeRestart(restart)
[15:32:50.952]                             muffled <- TRUE
[15:32:50.952]                             break
[15:32:50.952]                           }
[15:32:50.952]                         }
[15:32:50.952]                       }
[15:32:50.952]                       invisible(muffled)
[15:32:50.952]                     }
[15:32:50.952]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.952]                   }
[15:32:50.952]                 }
[15:32:50.952]                 else {
[15:32:50.952]                   if (TRUE) {
[15:32:50.952]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:50.952]                     {
[15:32:50.952]                       inherits <- base::inherits
[15:32:50.952]                       invokeRestart <- base::invokeRestart
[15:32:50.952]                       is.null <- base::is.null
[15:32:50.952]                       muffled <- FALSE
[15:32:50.952]                       if (inherits(cond, "message")) {
[15:32:50.952]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:50.952]                         if (muffled) 
[15:32:50.952]                           invokeRestart("muffleMessage")
[15:32:50.952]                       }
[15:32:50.952]                       else if (inherits(cond, "warning")) {
[15:32:50.952]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:50.952]                         if (muffled) 
[15:32:50.952]                           invokeRestart("muffleWarning")
[15:32:50.952]                       }
[15:32:50.952]                       else if (inherits(cond, "condition")) {
[15:32:50.952]                         if (!is.null(pattern)) {
[15:32:50.952]                           computeRestarts <- base::computeRestarts
[15:32:50.952]                           grepl <- base::grepl
[15:32:50.952]                           restarts <- computeRestarts(cond)
[15:32:50.952]                           for (restart in restarts) {
[15:32:50.952]                             name <- restart$name
[15:32:50.952]                             if (is.null(name)) 
[15:32:50.952]                               next
[15:32:50.952]                             if (!grepl(pattern, name)) 
[15:32:50.952]                               next
[15:32:50.952]                             invokeRestart(restart)
[15:32:50.952]                             muffled <- TRUE
[15:32:50.952]                             break
[15:32:50.952]                           }
[15:32:50.952]                         }
[15:32:50.952]                       }
[15:32:50.952]                       invisible(muffled)
[15:32:50.952]                     }
[15:32:50.952]                     muffleCondition(cond, pattern = "^muffle")
[15:32:50.952]                   }
[15:32:50.952]                 }
[15:32:50.952]             }
[15:32:50.952]         }))
[15:32:50.952]     }, error = function(ex) {
[15:32:50.952]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:50.952]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:50.952]                 ...future.rng), started = ...future.startTime, 
[15:32:50.952]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:50.952]             version = "1.8"), class = "FutureResult")
[15:32:50.952]     }, finally = {
[15:32:50.952]         if (!identical(...future.workdir, getwd())) 
[15:32:50.952]             setwd(...future.workdir)
[15:32:50.952]         {
[15:32:50.952]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:50.952]                 ...future.oldOptions$nwarnings <- NULL
[15:32:50.952]             }
[15:32:50.952]             base::options(...future.oldOptions)
[15:32:50.952]             if (.Platform$OS.type == "windows") {
[15:32:50.952]                 old_names <- names(...future.oldEnvVars)
[15:32:50.952]                 envs <- base::Sys.getenv()
[15:32:50.952]                 names <- names(envs)
[15:32:50.952]                 common <- intersect(names, old_names)
[15:32:50.952]                 added <- setdiff(names, old_names)
[15:32:50.952]                 removed <- setdiff(old_names, names)
[15:32:50.952]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:50.952]                   envs[common]]
[15:32:50.952]                 NAMES <- toupper(changed)
[15:32:50.952]                 args <- list()
[15:32:50.952]                 for (kk in seq_along(NAMES)) {
[15:32:50.952]                   name <- changed[[kk]]
[15:32:50.952]                   NAME <- NAMES[[kk]]
[15:32:50.952]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.952]                     next
[15:32:50.952]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.952]                 }
[15:32:50.952]                 NAMES <- toupper(added)
[15:32:50.952]                 for (kk in seq_along(NAMES)) {
[15:32:50.952]                   name <- added[[kk]]
[15:32:50.952]                   NAME <- NAMES[[kk]]
[15:32:50.952]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.952]                     next
[15:32:50.952]                   args[[name]] <- ""
[15:32:50.952]                 }
[15:32:50.952]                 NAMES <- toupper(removed)
[15:32:50.952]                 for (kk in seq_along(NAMES)) {
[15:32:50.952]                   name <- removed[[kk]]
[15:32:50.952]                   NAME <- NAMES[[kk]]
[15:32:50.952]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:50.952]                     next
[15:32:50.952]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:50.952]                 }
[15:32:50.952]                 if (length(args) > 0) 
[15:32:50.952]                   base::do.call(base::Sys.setenv, args = args)
[15:32:50.952]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:50.952]             }
[15:32:50.952]             else {
[15:32:50.952]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:50.952]             }
[15:32:50.952]             {
[15:32:50.952]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:50.952]                   0L) {
[15:32:50.952]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:50.952]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:50.952]                   base::options(opts)
[15:32:50.952]                 }
[15:32:50.952]                 {
[15:32:50.952]                   {
[15:32:50.952]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:50.952]                     NULL
[15:32:50.952]                   }
[15:32:50.952]                   options(future.plan = NULL)
[15:32:50.952]                   if (is.na(NA_character_)) 
[15:32:50.952]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:50.952]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:50.952]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:50.952]                     .init = FALSE)
[15:32:50.952]                 }
[15:32:50.952]             }
[15:32:50.952]         }
[15:32:50.952]     })
[15:32:50.952]     if (TRUE) {
[15:32:50.952]         base::sink(type = "output", split = FALSE)
[15:32:50.952]         if (TRUE) {
[15:32:50.952]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:50.952]         }
[15:32:50.952]         else {
[15:32:50.952]             ...future.result["stdout"] <- base::list(NULL)
[15:32:50.952]         }
[15:32:50.952]         base::close(...future.stdout)
[15:32:50.952]         ...future.stdout <- NULL
[15:32:50.952]     }
[15:32:50.952]     ...future.result$conditions <- ...future.conditions
[15:32:50.952]     ...future.result$finished <- base::Sys.time()
[15:32:50.952]     ...future.result
[15:32:50.952] }
[15:32:50.961] Exporting 11 global objects (92.90 KiB) to cluster node #1 ...
[15:32:50.962] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:50.963] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:50.963] Exporting 'x_FUN' (848 bytes) to cluster node #1 ...
[15:32:50.964] Exporting 'x_FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:50.964] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:50.965] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:50.965] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:50.966] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:50.966] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:50.967] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:50.967] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:50.968] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:50.968] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:50.969] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:50.969] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:50.970] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:50.970] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:32:50.971] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:32:50.971] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:50.972] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:50.972] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:50.973] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:50.973] Exporting 11 global objects (92.90 KiB) to cluster node #1 ... DONE
[15:32:50.974] MultisessionFuture started
[15:32:50.974] - Launch lazy future ... done
[15:32:50.975] run() for 'MultisessionFuture' ... done
[15:32:50.975] Created future:
[15:32:51.002] receiveMessageFromWorker() for ClusterFuture ...
[15:32:51.003] - Validating connection of MultisessionFuture
[15:32:51.003] - received message: FutureResult
[15:32:51.004] - Received FutureResult
[15:32:51.004] - Erased future from FutureRegistry
[15:32:51.004] result() for ClusterFuture ...
[15:32:51.005] - result already collected: FutureResult
[15:32:51.005] result() for ClusterFuture ... done
[15:32:51.005] signalConditions() ...
[15:32:51.005]  - include = 'immediateCondition'
[15:32:51.006]  - exclude = 
[15:32:51.006]  - resignal = FALSE
[15:32:51.006]  - Number of conditions: 1
[15:32:51.007] signalConditions() ... done
[15:32:51.007] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:50.975] MultisessionFuture:
[15:32:50.975] Label: 'future_vapply-1'
[15:32:50.975] Expression:
[15:32:50.975] {
[15:32:50.975]     do.call(function(...) {
[15:32:50.975]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:50.975]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:50.975]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:50.975]             on.exit(options(oopts), add = TRUE)
[15:32:50.975]         }
[15:32:50.975]         {
[15:32:50.975]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:50.975]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:50.975]                 ...future.FUN(...future.X_jj, ...)
[15:32:50.975]             })
[15:32:50.975]         }
[15:32:50.975]     }, args = future.call.arguments)
[15:32:50.975] }
[15:32:50.975] Lazy evaluation: FALSE
[15:32:50.975] Asynchronous evaluation: TRUE
[15:32:50.975] Local evaluation: TRUE
[15:32:50.975] Environment: R_GlobalEnv
[15:32:50.975] Capture standard output: TRUE
[15:32:50.975] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:50.975] Globals: 11 objects totaling 92.95 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 848 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:50.975] Packages: 1 packages ('future.apply')
[15:32:50.975] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:50.975] Resolved: TRUE
[15:32:50.975] Value: <not collected>
[15:32:50.975] Conditions captured: <none>
[15:32:50.975] Early signaling: FALSE
[15:32:50.975] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:50.975] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:51.008] Chunk #1 of 2 ... DONE
[15:32:51.008] Chunk #2 of 2 ...
[15:32:51.008]  - Finding globals in 'X' for chunk #2 ...
[15:32:51.008] getGlobalsAndPackages() ...
[15:32:51.009] Searching for globals...
[15:32:51.009] 
[15:32:51.009] Searching for globals ... DONE
[15:32:51.010] - globals: [0] <none>
[15:32:51.010] getGlobalsAndPackages() ... DONE
[15:32:51.010]    + additional globals found: [n=0] 
[15:32:51.010]    + additional namespaces needed: [n=0] 
[15:32:51.011]  - Finding globals in 'X' for chunk #2 ... DONE
[15:32:51.011]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:32:51.011]  - seeds: <none>
[15:32:51.011]  - All globals exported: [n=11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:51.012] getGlobalsAndPackages() ...
[15:32:51.012] - globals passed as-is: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:51.012] Resolving globals: FALSE
[15:32:51.013] Tweak future expression to call with '...' arguments ...
[15:32:51.013] {
[15:32:51.013]     do.call(function(...) {
[15:32:51.013]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:51.013]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:51.013]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:51.013]             on.exit(options(oopts), add = TRUE)
[15:32:51.013]         }
[15:32:51.013]         {
[15:32:51.013]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:51.013]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:51.013]                 ...future.FUN(...future.X_jj, ...)
[15:32:51.013]             })
[15:32:51.013]         }
[15:32:51.013]     }, args = future.call.arguments)
[15:32:51.013] }
[15:32:51.014] Tweak future expression to call with '...' arguments ... DONE
[15:32:51.015] - globals: [11] '...future.FUN', 'x_FUN', 'times', 'stopf', 'stop_if_not', 'dim', 'valid_types', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:32:51.015] - packages: [1] 'future.apply'
[15:32:51.015] getGlobalsAndPackages() ... DONE
[15:32:51.016] run() for 'Future' ...
[15:32:51.016] - state: 'created'
[15:32:51.016] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:32:51.034] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:51.034] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:32:51.034]   - Field: 'node'
[15:32:51.035]   - Field: 'label'
[15:32:51.035]   - Field: 'local'
[15:32:51.035]   - Field: 'owner'
[15:32:51.036]   - Field: 'envir'
[15:32:51.036]   - Field: 'workers'
[15:32:51.036]   - Field: 'packages'
[15:32:51.037]   - Field: 'gc'
[15:32:51.037]   - Field: 'conditions'
[15:32:51.037]   - Field: 'persistent'
[15:32:51.038]   - Field: 'expr'
[15:32:51.038]   - Field: 'uuid'
[15:32:51.038]   - Field: 'seed'
[15:32:51.039]   - Field: 'version'
[15:32:51.039]   - Field: 'result'
[15:32:51.039]   - Field: 'asynchronous'
[15:32:51.040]   - Field: 'calls'
[15:32:51.040]   - Field: 'globals'
[15:32:51.040]   - Field: 'stdout'
[15:32:51.041]   - Field: 'earlySignal'
[15:32:51.041]   - Field: 'lazy'
[15:32:51.041]   - Field: 'state'
[15:32:51.042] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:32:51.042] - Launch lazy future ...
[15:32:51.042] Packages needed by the future expression (n = 1): 'future.apply'
[15:32:51.043] Packages needed by future strategies (n = 0): <none>
[15:32:51.044] {
[15:32:51.044]     {
[15:32:51.044]         {
[15:32:51.044]             ...future.startTime <- base::Sys.time()
[15:32:51.044]             {
[15:32:51.044]                 {
[15:32:51.044]                   {
[15:32:51.044]                     {
[15:32:51.044]                       {
[15:32:51.044]                         base::local({
[15:32:51.044]                           has_future <- base::requireNamespace("future", 
[15:32:51.044]                             quietly = TRUE)
[15:32:51.044]                           if (has_future) {
[15:32:51.044]                             ns <- base::getNamespace("future")
[15:32:51.044]                             version <- ns[[".package"]][["version"]]
[15:32:51.044]                             if (is.null(version)) 
[15:32:51.044]                               version <- utils::packageVersion("future")
[15:32:51.044]                           }
[15:32:51.044]                           else {
[15:32:51.044]                             version <- NULL
[15:32:51.044]                           }
[15:32:51.044]                           if (!has_future || version < "1.8.0") {
[15:32:51.044]                             info <- base::c(r_version = base::gsub("R version ", 
[15:32:51.044]                               "", base::R.version$version.string), 
[15:32:51.044]                               platform = base::sprintf("%s (%s-bit)", 
[15:32:51.044]                                 base::R.version$platform, 8 * 
[15:32:51.044]                                   base::.Machine$sizeof.pointer), 
[15:32:51.044]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:32:51.044]                                 "release", "version")], collapse = " "), 
[15:32:51.044]                               hostname = base::Sys.info()[["nodename"]])
[15:32:51.044]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:32:51.044]                               info)
[15:32:51.044]                             info <- base::paste(info, collapse = "; ")
[15:32:51.044]                             if (!has_future) {
[15:32:51.044]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:32:51.044]                                 info)
[15:32:51.044]                             }
[15:32:51.044]                             else {
[15:32:51.044]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:32:51.044]                                 info, version)
[15:32:51.044]                             }
[15:32:51.044]                             base::stop(msg)
[15:32:51.044]                           }
[15:32:51.044]                         })
[15:32:51.044]                       }
[15:32:51.044]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:32:51.044]                       base::options(mc.cores = 1L)
[15:32:51.044]                     }
[15:32:51.044]                     base::local({
[15:32:51.044]                       for (pkg in "future.apply") {
[15:32:51.044]                         base::loadNamespace(pkg)
[15:32:51.044]                         base::library(pkg, character.only = TRUE)
[15:32:51.044]                       }
[15:32:51.044]                     })
[15:32:51.044]                   }
[15:32:51.044]                   ...future.strategy.old <- future::plan("list")
[15:32:51.044]                   options(future.plan = NULL)
[15:32:51.044]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:32:51.044]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:32:51.044]                 }
[15:32:51.044]                 ...future.workdir <- getwd()
[15:32:51.044]             }
[15:32:51.044]             ...future.oldOptions <- base::as.list(base::.Options)
[15:32:51.044]             ...future.oldEnvVars <- base::Sys.getenv()
[15:32:51.044]         }
[15:32:51.044]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:32:51.044]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:32:51.044]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:32:51.044]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:32:51.044]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:32:51.044]             future.stdout.windows.reencode = NULL, width = 80L)
[15:32:51.044]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:32:51.044]             base::names(...future.oldOptions))
[15:32:51.044]     }
[15:32:51.044]     if (FALSE) {
[15:32:51.044]     }
[15:32:51.044]     else {
[15:32:51.044]         if (TRUE) {
[15:32:51.044]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:32:51.044]                 open = "w")
[15:32:51.044]         }
[15:32:51.044]         else {
[15:32:51.044]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:32:51.044]                 windows = "NUL", "/dev/null"), open = "w")
[15:32:51.044]         }
[15:32:51.044]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:32:51.044]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:32:51.044]             base::sink(type = "output", split = FALSE)
[15:32:51.044]             base::close(...future.stdout)
[15:32:51.044]         }, add = TRUE)
[15:32:51.044]     }
[15:32:51.044]     ...future.frame <- base::sys.nframe()
[15:32:51.044]     ...future.conditions <- base::list()
[15:32:51.044]     ...future.rng <- base::globalenv()$.Random.seed
[15:32:51.044]     if (FALSE) {
[15:32:51.044]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:32:51.044]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:32:51.044]     }
[15:32:51.044]     ...future.result <- base::tryCatch({
[15:32:51.044]         base::withCallingHandlers({
[15:32:51.044]             ...future.value <- base::withVisible(base::local({
[15:32:51.044]                 ...future.makeSendCondition <- base::local({
[15:32:51.044]                   sendCondition <- NULL
[15:32:51.044]                   function(frame = 1L) {
[15:32:51.044]                     if (is.function(sendCondition)) 
[15:32:51.044]                       return(sendCondition)
[15:32:51.044]                     ns <- getNamespace("parallel")
[15:32:51.044]                     if (exists("sendData", mode = "function", 
[15:32:51.044]                       envir = ns)) {
[15:32:51.044]                       parallel_sendData <- get("sendData", mode = "function", 
[15:32:51.044]                         envir = ns)
[15:32:51.044]                       envir <- sys.frame(frame)
[15:32:51.044]                       master <- NULL
[15:32:51.044]                       while (!identical(envir, .GlobalEnv) && 
[15:32:51.044]                         !identical(envir, emptyenv())) {
[15:32:51.044]                         if (exists("master", mode = "list", envir = envir, 
[15:32:51.044]                           inherits = FALSE)) {
[15:32:51.044]                           master <- get("master", mode = "list", 
[15:32:51.044]                             envir = envir, inherits = FALSE)
[15:32:51.044]                           if (inherits(master, c("SOCKnode", 
[15:32:51.044]                             "SOCK0node"))) {
[15:32:51.044]                             sendCondition <<- function(cond) {
[15:32:51.044]                               data <- list(type = "VALUE", value = cond, 
[15:32:51.044]                                 success = TRUE)
[15:32:51.044]                               parallel_sendData(master, data)
[15:32:51.044]                             }
[15:32:51.044]                             return(sendCondition)
[15:32:51.044]                           }
[15:32:51.044]                         }
[15:32:51.044]                         frame <- frame + 1L
[15:32:51.044]                         envir <- sys.frame(frame)
[15:32:51.044]                       }
[15:32:51.044]                     }
[15:32:51.044]                     sendCondition <<- function(cond) NULL
[15:32:51.044]                   }
[15:32:51.044]                 })
[15:32:51.044]                 withCallingHandlers({
[15:32:51.044]                   {
[15:32:51.044]                     do.call(function(...) {
[15:32:51.044]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:51.044]                       if (!identical(...future.globals.maxSize.org, 
[15:32:51.044]                         ...future.globals.maxSize)) {
[15:32:51.044]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:51.044]                         on.exit(options(oopts), add = TRUE)
[15:32:51.044]                       }
[15:32:51.044]                       {
[15:32:51.044]                         lapply(seq_along(...future.elements_ii), 
[15:32:51.044]                           FUN = function(jj) {
[15:32:51.044]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:51.044]                             ...future.FUN(...future.X_jj, ...)
[15:32:51.044]                           })
[15:32:51.044]                       }
[15:32:51.044]                     }, args = future.call.arguments)
[15:32:51.044]                   }
[15:32:51.044]                 }, immediateCondition = function(cond) {
[15:32:51.044]                   sendCondition <- ...future.makeSendCondition()
[15:32:51.044]                   sendCondition(cond)
[15:32:51.044]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:51.044]                   {
[15:32:51.044]                     inherits <- base::inherits
[15:32:51.044]                     invokeRestart <- base::invokeRestart
[15:32:51.044]                     is.null <- base::is.null
[15:32:51.044]                     muffled <- FALSE
[15:32:51.044]                     if (inherits(cond, "message")) {
[15:32:51.044]                       muffled <- grepl(pattern, "muffleMessage")
[15:32:51.044]                       if (muffled) 
[15:32:51.044]                         invokeRestart("muffleMessage")
[15:32:51.044]                     }
[15:32:51.044]                     else if (inherits(cond, "warning")) {
[15:32:51.044]                       muffled <- grepl(pattern, "muffleWarning")
[15:32:51.044]                       if (muffled) 
[15:32:51.044]                         invokeRestart("muffleWarning")
[15:32:51.044]                     }
[15:32:51.044]                     else if (inherits(cond, "condition")) {
[15:32:51.044]                       if (!is.null(pattern)) {
[15:32:51.044]                         computeRestarts <- base::computeRestarts
[15:32:51.044]                         grepl <- base::grepl
[15:32:51.044]                         restarts <- computeRestarts(cond)
[15:32:51.044]                         for (restart in restarts) {
[15:32:51.044]                           name <- restart$name
[15:32:51.044]                           if (is.null(name)) 
[15:32:51.044]                             next
[15:32:51.044]                           if (!grepl(pattern, name)) 
[15:32:51.044]                             next
[15:32:51.044]                           invokeRestart(restart)
[15:32:51.044]                           muffled <- TRUE
[15:32:51.044]                           break
[15:32:51.044]                         }
[15:32:51.044]                       }
[15:32:51.044]                     }
[15:32:51.044]                     invisible(muffled)
[15:32:51.044]                   }
[15:32:51.044]                   muffleCondition(cond)
[15:32:51.044]                 })
[15:32:51.044]             }))
[15:32:51.044]             future::FutureResult(value = ...future.value$value, 
[15:32:51.044]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:51.044]                   ...future.rng), globalenv = if (FALSE) 
[15:32:51.044]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:32:51.044]                     ...future.globalenv.names))
[15:32:51.044]                 else NULL, started = ...future.startTime, version = "1.8")
[15:32:51.044]         }, condition = base::local({
[15:32:51.044]             c <- base::c
[15:32:51.044]             inherits <- base::inherits
[15:32:51.044]             invokeRestart <- base::invokeRestart
[15:32:51.044]             length <- base::length
[15:32:51.044]             list <- base::list
[15:32:51.044]             seq.int <- base::seq.int
[15:32:51.044]             signalCondition <- base::signalCondition
[15:32:51.044]             sys.calls <- base::sys.calls
[15:32:51.044]             `[[` <- base::`[[`
[15:32:51.044]             `+` <- base::`+`
[15:32:51.044]             `<<-` <- base::`<<-`
[15:32:51.044]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:32:51.044]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:32:51.044]                   3L)]
[15:32:51.044]             }
[15:32:51.044]             function(cond) {
[15:32:51.044]                 is_error <- inherits(cond, "error")
[15:32:51.044]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:32:51.044]                   NULL)
[15:32:51.044]                 if (is_error) {
[15:32:51.044]                   sessionInformation <- function() {
[15:32:51.044]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:32:51.044]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:32:51.044]                       search = base::search(), system = base::Sys.info())
[15:32:51.044]                   }
[15:32:51.044]                   ...future.conditions[[length(...future.conditions) + 
[15:32:51.044]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:32:51.044]                     cond$call), session = sessionInformation(), 
[15:32:51.044]                     timestamp = base::Sys.time(), signaled = 0L)
[15:32:51.044]                   signalCondition(cond)
[15:32:51.044]                 }
[15:32:51.044]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:32:51.044]                 "immediateCondition"))) {
[15:32:51.044]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:32:51.044]                   ...future.conditions[[length(...future.conditions) + 
[15:32:51.044]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:32:51.044]                   if (TRUE && !signal) {
[15:32:51.044]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:51.044]                     {
[15:32:51.044]                       inherits <- base::inherits
[15:32:51.044]                       invokeRestart <- base::invokeRestart
[15:32:51.044]                       is.null <- base::is.null
[15:32:51.044]                       muffled <- FALSE
[15:32:51.044]                       if (inherits(cond, "message")) {
[15:32:51.044]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:51.044]                         if (muffled) 
[15:32:51.044]                           invokeRestart("muffleMessage")
[15:32:51.044]                       }
[15:32:51.044]                       else if (inherits(cond, "warning")) {
[15:32:51.044]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:51.044]                         if (muffled) 
[15:32:51.044]                           invokeRestart("muffleWarning")
[15:32:51.044]                       }
[15:32:51.044]                       else if (inherits(cond, "condition")) {
[15:32:51.044]                         if (!is.null(pattern)) {
[15:32:51.044]                           computeRestarts <- base::computeRestarts
[15:32:51.044]                           grepl <- base::grepl
[15:32:51.044]                           restarts <- computeRestarts(cond)
[15:32:51.044]                           for (restart in restarts) {
[15:32:51.044]                             name <- restart$name
[15:32:51.044]                             if (is.null(name)) 
[15:32:51.044]                               next
[15:32:51.044]                             if (!grepl(pattern, name)) 
[15:32:51.044]                               next
[15:32:51.044]                             invokeRestart(restart)
[15:32:51.044]                             muffled <- TRUE
[15:32:51.044]                             break
[15:32:51.044]                           }
[15:32:51.044]                         }
[15:32:51.044]                       }
[15:32:51.044]                       invisible(muffled)
[15:32:51.044]                     }
[15:32:51.044]                     muffleCondition(cond, pattern = "^muffle")
[15:32:51.044]                   }
[15:32:51.044]                 }
[15:32:51.044]                 else {
[15:32:51.044]                   if (TRUE) {
[15:32:51.044]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:32:51.044]                     {
[15:32:51.044]                       inherits <- base::inherits
[15:32:51.044]                       invokeRestart <- base::invokeRestart
[15:32:51.044]                       is.null <- base::is.null
[15:32:51.044]                       muffled <- FALSE
[15:32:51.044]                       if (inherits(cond, "message")) {
[15:32:51.044]                         muffled <- grepl(pattern, "muffleMessage")
[15:32:51.044]                         if (muffled) 
[15:32:51.044]                           invokeRestart("muffleMessage")
[15:32:51.044]                       }
[15:32:51.044]                       else if (inherits(cond, "warning")) {
[15:32:51.044]                         muffled <- grepl(pattern, "muffleWarning")
[15:32:51.044]                         if (muffled) 
[15:32:51.044]                           invokeRestart("muffleWarning")
[15:32:51.044]                       }
[15:32:51.044]                       else if (inherits(cond, "condition")) {
[15:32:51.044]                         if (!is.null(pattern)) {
[15:32:51.044]                           computeRestarts <- base::computeRestarts
[15:32:51.044]                           grepl <- base::grepl
[15:32:51.044]                           restarts <- computeRestarts(cond)
[15:32:51.044]                           for (restart in restarts) {
[15:32:51.044]                             name <- restart$name
[15:32:51.044]                             if (is.null(name)) 
[15:32:51.044]                               next
[15:32:51.044]                             if (!grepl(pattern, name)) 
[15:32:51.044]                               next
[15:32:51.044]                             invokeRestart(restart)
[15:32:51.044]                             muffled <- TRUE
[15:32:51.044]                             break
[15:32:51.044]                           }
[15:32:51.044]                         }
[15:32:51.044]                       }
[15:32:51.044]                       invisible(muffled)
[15:32:51.044]                     }
[15:32:51.044]                     muffleCondition(cond, pattern = "^muffle")
[15:32:51.044]                   }
[15:32:51.044]                 }
[15:32:51.044]             }
[15:32:51.044]         }))
[15:32:51.044]     }, error = function(ex) {
[15:32:51.044]         base::structure(base::list(value = NULL, visible = NULL, 
[15:32:51.044]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:32:51.044]                 ...future.rng), started = ...future.startTime, 
[15:32:51.044]             finished = Sys.time(), session_uuid = NA_character_, 
[15:32:51.044]             version = "1.8"), class = "FutureResult")
[15:32:51.044]     }, finally = {
[15:32:51.044]         if (!identical(...future.workdir, getwd())) 
[15:32:51.044]             setwd(...future.workdir)
[15:32:51.044]         {
[15:32:51.044]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:32:51.044]                 ...future.oldOptions$nwarnings <- NULL
[15:32:51.044]             }
[15:32:51.044]             base::options(...future.oldOptions)
[15:32:51.044]             if (.Platform$OS.type == "windows") {
[15:32:51.044]                 old_names <- names(...future.oldEnvVars)
[15:32:51.044]                 envs <- base::Sys.getenv()
[15:32:51.044]                 names <- names(envs)
[15:32:51.044]                 common <- intersect(names, old_names)
[15:32:51.044]                 added <- setdiff(names, old_names)
[15:32:51.044]                 removed <- setdiff(old_names, names)
[15:32:51.044]                 changed <- common[...future.oldEnvVars[common] != 
[15:32:51.044]                   envs[common]]
[15:32:51.044]                 NAMES <- toupper(changed)
[15:32:51.044]                 args <- list()
[15:32:51.044]                 for (kk in seq_along(NAMES)) {
[15:32:51.044]                   name <- changed[[kk]]
[15:32:51.044]                   NAME <- NAMES[[kk]]
[15:32:51.044]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:51.044]                     next
[15:32:51.044]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:51.044]                 }
[15:32:51.044]                 NAMES <- toupper(added)
[15:32:51.044]                 for (kk in seq_along(NAMES)) {
[15:32:51.044]                   name <- added[[kk]]
[15:32:51.044]                   NAME <- NAMES[[kk]]
[15:32:51.044]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:51.044]                     next
[15:32:51.044]                   args[[name]] <- ""
[15:32:51.044]                 }
[15:32:51.044]                 NAMES <- toupper(removed)
[15:32:51.044]                 for (kk in seq_along(NAMES)) {
[15:32:51.044]                   name <- removed[[kk]]
[15:32:51.044]                   NAME <- NAMES[[kk]]
[15:32:51.044]                   if (name != NAME && is.element(NAME, old_names)) 
[15:32:51.044]                     next
[15:32:51.044]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:32:51.044]                 }
[15:32:51.044]                 if (length(args) > 0) 
[15:32:51.044]                   base::do.call(base::Sys.setenv, args = args)
[15:32:51.044]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:32:51.044]             }
[15:32:51.044]             else {
[15:32:51.044]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:32:51.044]             }
[15:32:51.044]             {
[15:32:51.044]                 if (base::length(...future.futureOptionsAdded) > 
[15:32:51.044]                   0L) {
[15:32:51.044]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:32:51.044]                   base::names(opts) <- ...future.futureOptionsAdded
[15:32:51.044]                   base::options(opts)
[15:32:51.044]                 }
[15:32:51.044]                 {
[15:32:51.044]                   {
[15:32:51.044]                     base::options(mc.cores = ...future.mc.cores.old)
[15:32:51.044]                     NULL
[15:32:51.044]                   }
[15:32:51.044]                   options(future.plan = NULL)
[15:32:51.044]                   if (is.na(NA_character_)) 
[15:32:51.044]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:32:51.044]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:32:51.044]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:32:51.044]                     .init = FALSE)
[15:32:51.044]                 }
[15:32:51.044]             }
[15:32:51.044]         }
[15:32:51.044]     })
[15:32:51.044]     if (TRUE) {
[15:32:51.044]         base::sink(type = "output", split = FALSE)
[15:32:51.044]         if (TRUE) {
[15:32:51.044]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:32:51.044]         }
[15:32:51.044]         else {
[15:32:51.044]             ...future.result["stdout"] <- base::list(NULL)
[15:32:51.044]         }
[15:32:51.044]         base::close(...future.stdout)
[15:32:51.044]         ...future.stdout <- NULL
[15:32:51.044]     }
[15:32:51.044]     ...future.result$conditions <- ...future.conditions
[15:32:51.044]     ...future.result$finished <- base::Sys.time()
[15:32:51.044]     ...future.result
[15:32:51.044] }
[15:32:51.051] Exporting 11 global objects (92.90 KiB) to cluster node #1 ...
[15:32:51.052] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ...
[15:32:51.053] Exporting '...future.FUN' (21.22 KiB) to cluster node #1 ... DONE
[15:32:51.053] Exporting 'x_FUN' (848 bytes) to cluster node #1 ...
[15:32:51.054] Exporting 'x_FUN' (848 bytes) to cluster node #1 ... DONE
[15:32:51.054] Exporting 'times' (56 bytes) to cluster node #1 ...
[15:32:51.055] Exporting 'times' (56 bytes) to cluster node #1 ... DONE
[15:32:51.055] Exporting 'stopf' (26.43 KiB) to cluster node #1 ...
[15:32:51.056] Exporting 'stopf' (26.43 KiB) to cluster node #1 ... DONE
[15:32:51.056] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ...
[15:32:51.057] Exporting 'stop_if_not' (44.12 KiB) to cluster node #1 ... DONE
[15:32:51.057] Exporting 'dim' (0 bytes) to cluster node #1 ...
[15:32:51.058] Exporting 'dim' (0 bytes) to cluster node #1 ... DONE
[15:32:51.058] Exporting 'valid_types' (248 bytes) to cluster node #1 ...
[15:32:51.059] Exporting 'valid_types' (248 bytes) to cluster node #1 ... DONE
[15:32:51.060] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:32:51.060] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:32:51.060] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:32:51.061] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:32:51.061] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:32:51.062] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:32:51.063] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:32:51.064] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:32:51.064] Exporting 11 global objects (92.90 KiB) to cluster node #1 ... DONE
[15:32:51.065] MultisessionFuture started
[15:32:51.066] - Launch lazy future ... done
[15:32:51.066] run() for 'MultisessionFuture' ... done
[15:32:51.066] Created future:
[15:32:51.094] receiveMessageFromWorker() for ClusterFuture ...
[15:32:51.094] - Validating connection of MultisessionFuture
[15:32:51.095] - received message: FutureResult
[15:32:51.095] - Received FutureResult
[15:32:51.096] - Erased future from FutureRegistry
[15:32:51.096] result() for ClusterFuture ...
[15:32:51.096] - result already collected: FutureResult
[15:32:51.096] result() for ClusterFuture ... done
[15:32:51.097] signalConditions() ...
[15:32:51.097]  - include = 'immediateCondition'
[15:32:51.097]  - exclude = 
[15:32:51.097]  - resignal = FALSE
[15:32:51.098]  - Number of conditions: 1
[15:32:51.098] signalConditions() ... done
[15:32:51.098] receiveMessageFromWorker() for ClusterFuture ... done
[15:32:51.066] MultisessionFuture:
[15:32:51.066] Label: 'future_vapply-2'
[15:32:51.066] Expression:
[15:32:51.066] {
[15:32:51.066]     do.call(function(...) {
[15:32:51.066]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:32:51.066]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:32:51.066]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:32:51.066]             on.exit(options(oopts), add = TRUE)
[15:32:51.066]         }
[15:32:51.066]         {
[15:32:51.066]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:32:51.066]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:32:51.066]                 ...future.FUN(...future.X_jj, ...)
[15:32:51.066]             })
[15:32:51.066]         }
[15:32:51.066]     }, args = future.call.arguments)
[15:32:51.066] }
[15:32:51.066] Lazy evaluation: FALSE
[15:32:51.066] Asynchronous evaluation: TRUE
[15:32:51.066] Local evaluation: TRUE
[15:32:51.066] Environment: R_GlobalEnv
[15:32:51.066] Capture standard output: TRUE
[15:32:51.066] Capture condition classes: 'condition' (excluding 'nothing')
[15:32:51.066] Globals: 11 objects totaling 93.01 KiB (function '...future.FUN' of 21.22 KiB, function 'x_FUN' of 848 bytes, integer 'times' of 56 bytes, function 'stopf' of 26.43 KiB, function 'stop_if_not' of 44.12 KiB, ...)
[15:32:51.066] Packages: 1 packages ('future.apply')
[15:32:51.066] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:32:51.066] Resolved: TRUE
[15:32:51.066] Value: <not collected>
[15:32:51.066] Conditions captured: <none>
[15:32:51.066] Early signaling: FALSE
[15:32:51.066] Owner process: 0cca62ae-9a80-47b2-a28d-9d7bb52fa089
[15:32:51.066] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:32:51.099] Chunk #2 of 2 ... DONE
[15:32:51.099] Launching 2 futures (chunks) ... DONE
[15:32:51.099] Resolving 2 futures (chunks) ...
[15:32:51.100] resolve() on list ...
[15:32:51.100]  recursive: 0
[15:32:51.100]  length: 2
[15:32:51.101] 
[15:32:51.101] Future #1
[15:32:51.101] result() for ClusterFuture ...
[15:32:51.101] - result already collected: FutureResult
[15:32:51.102] result() for ClusterFuture ... done
[15:32:51.102] result() for ClusterFuture ...
[15:32:51.102] - result already collected: FutureResult
[15:32:51.102] result() for ClusterFuture ... done
[15:32:51.103] signalConditions() ...
[15:32:51.103]  - include = 'immediateCondition'
[15:32:51.103]  - exclude = 
[15:32:51.103]  - resignal = FALSE
[15:32:51.104]  - Number of conditions: 1
[15:32:51.104] signalConditions() ... done
[15:32:51.104] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:32:51.105] - nx: 2
[15:32:51.105] - relay: TRUE
[15:32:51.105] - stdout: TRUE
[15:32:51.105] - signal: TRUE
[15:32:51.106] - resignal: FALSE
[15:32:51.106] - force: TRUE
[15:32:51.106] - relayed: [n=2] FALSE, FALSE
[15:32:51.106] - queued futures: [n=2] FALSE, FALSE
[15:32:51.107]  - until=1
[15:32:51.107]  - relaying element #1
[15:32:51.107] result() for ClusterFuture ...
[15:32:51.108] - result already collected: FutureResult
[15:32:51.108] result() for ClusterFuture ... done
[15:32:51.108] result() for ClusterFuture ...
[15:32:51.108] - result already collected: FutureResult
[15:32:51.109] result() for ClusterFuture ... done
[15:32:51.109] signalConditions() ...
[15:32:51.109]  - include = 'immediateCondition'
[15:32:51.109]  - exclude = 
[15:32:51.110]  - resignal = FALSE
[15:32:51.110]  - Number of conditions: 1
[15:32:51.110] signalConditions() ... done
[15:32:51.111] result() for ClusterFuture ...
[15:32:51.111] - result already collected: FutureResult
[15:32:51.111] result() for ClusterFuture ... done
[15:32:51.111] signalConditions() ...
[15:32:51.112]  - include = 'immediateCondition'
[15:32:51.112]  - exclude = 
[15:32:51.112]  - resignal = FALSE
[15:32:51.113]  - Number of conditions: 1
[15:32:51.113] signalConditions() ... done
[15:32:51.113] result() for ClusterFuture ...
[15:32:51.113] - result already collected: FutureResult
[15:32:51.114] result() for ClusterFuture ... done
[15:32:51.114] signalConditions() ...
[15:32:51.114]  - include = 'condition'
[15:32:51.114]  - exclude = 'immediateCondition'
[15:32:51.115]  - resignal = TRUE
[15:32:51.115]  - Number of conditions: 1
[15:32:51.115]  - Condition #1: 'simpleError', 'error', 'condition'
[15:32:51.116] signalConditions() ... done
[15:32:51.116] - relayed: [n=2] FALSE, FALSE
[15:32:51.116] - queued futures: [n=2] TRUE, FALSE
[15:32:51.116] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:32:51.117] plan(): Setting new future strategy stack:
[15:32:51.117] List of future strategies:
[15:32:51.117] 1. sequential:
[15:32:51.117]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:51.117]    - tweaked: FALSE
[15:32:51.117]    - call: plan(sequential)
[15:32:51.119] plan(): nbrOfWorkers() = 1
*** strategy = 'multisession' ... done
> 
> 
> message("*** future_vapply() ... DONE")
*** future_vapply() ... DONE
> 
> source("incl/end.R")
[15:32:51.120] plan(): Setting new future strategy stack:
[15:32:51.121] List of future strategies:
[15:32:51.121] 1. FutureStrategy:
[15:32:51.121]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:32:51.121]    - tweaked: FALSE
[15:32:51.121]    - call: future::plan(oplan)
[15:32:51.122] plan(): nbrOfWorkers() = 1
> 
> proc.time()
   user  system elapsed 
   5.67    0.28    7.70