From 56635c9a88ec94b60285bfa148989044a6280918 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rados=C5=82aw=20Wa=C5=9Bko?= Date: Fri, 21 Jul 2023 19:25:02 +0200 Subject: [PATCH] Add benchmarks comparing performance of Table operations 'vectorized' in Java vs performed in Enso (#7270) The added benchmark is a basis for a performance investigation. We compare the performance of the same operation run in Java vs Enso to see what is the overhead and try to get the Enso operations closer to the pure-Java performance. --- build.sbt | 26 +- .../Table/0.0.0-dev/src/Data/Column.enso | 3 +- .../Standard/Test/0.0.0-dev/src/Bench.enso | 15 +- .../org/enso/table/data/table/Column.java | 33 +- test/Exploratory_Benchmarks/README.md | 52 + test/Exploratory_Benchmarks/package.yaml | 6 + .../MapHelpers.java | 109 + .../SimpleStorageAggregateHelpers.java | 46 + test/Exploratory_Benchmarks/src/Main.enso | 3 + .../src/Table/Column_Aggregate.enso | 127 + .../src/Table/Column_Bi_Map.enso | 104 + .../src/Table/Column_Map.enso | 111 + .../src/Table/Column_Map_2.enso | 77 + .../src/Table/Common_Setup.enso | 19 + .../src/Table/Enso_Callback.enso | 140 + .../src/Table/Helpers.enso | 34 + .../src/Table/Main.enso | 19 + .../performance/benchmark-analysis/README.md | 5 + .../benchmarks-vectorized-3-2023-07-17.txt | 5050 +++++++++++++++++ .../benchmark-analysis/package.yaml | 8 + .../benchmark-analysis/src/Main.enso | 59 + 21 files changed, 6031 insertions(+), 15 deletions(-) create mode 100644 test/Exploratory_Benchmarks/README.md create mode 100644 test/Exploratory_Benchmarks/package.yaml create mode 100644 test/Exploratory_Benchmarks/polyglot-sources/exploratory-benchmark-java-helpers/src/main/java/org/enso/exploratory_benchmark_helpers/MapHelpers.java create mode 100644 test/Exploratory_Benchmarks/polyglot-sources/exploratory-benchmark-java-helpers/src/main/java/org/enso/exploratory_benchmark_helpers/SimpleStorageAggregateHelpers.java create mode 100644 test/Exploratory_Benchmarks/src/Main.enso create mode 100644 test/Exploratory_Benchmarks/src/Table/Column_Aggregate.enso create mode 100644 test/Exploratory_Benchmarks/src/Table/Column_Bi_Map.enso create mode 100644 test/Exploratory_Benchmarks/src/Table/Column_Map.enso create mode 100644 test/Exploratory_Benchmarks/src/Table/Column_Map_2.enso create mode 100644 test/Exploratory_Benchmarks/src/Table/Common_Setup.enso create mode 100644 test/Exploratory_Benchmarks/src/Table/Enso_Callback.enso create mode 100644 test/Exploratory_Benchmarks/src/Table/Helpers.enso create mode 100644 test/Exploratory_Benchmarks/src/Table/Main.enso create mode 100644 tools/performance/benchmark-analysis/README.md create mode 100644 tools/performance/benchmark-analysis/data/benchmarks-vectorized-3-2023-07-17.txt create mode 100644 tools/performance/benchmark-analysis/package.yaml create mode 100644 tools/performance/benchmark-analysis/src/Main.enso diff --git a/build.sbt b/build.sbt index 2da06505730..bab799c5855 100644 --- a/build.sbt +++ b/build.sbt @@ -303,7 +303,8 @@ lazy val enso = (project in file(".")) `std-table`, `std-aws`, `simple-httpbin`, - `enso-test-java-helpers` + `enso-test-java-helpers`, + `exploratory-benchmark-java-helpers` ) .settings(Global / concurrentRestrictions += Tags.exclusive(Exclusive)) .settings( @@ -1359,6 +1360,7 @@ lazy val runtime = (project in file("engine/runtime")) (Runtime / compile) := (Runtime / compile) .dependsOn(`std-base` / Compile / packageBin) .dependsOn(`enso-test-java-helpers` / Compile / packageBin) + .dependsOn(`exploratory-benchmark-java-helpers` / Compile / packageBin) .dependsOn(`std-image` / Compile / packageBin) .dependsOn(`std-database` / Compile / packageBin) .dependsOn(`std-google-api` / Compile / packageBin) @@ -2017,6 +2019,26 @@ lazy val `enso-test-java-helpers` = project .dependsOn(`std-base` % "provided") .dependsOn(`std-table` % "provided") +lazy val `exploratory-benchmark-java-helpers` = project + .in( + file( + "test/Exploratory_Benchmarks/polyglot-sources/exploratory-benchmark-java-helpers" + ) + ) + .settings( + frgaalJavaCompilerSetting, + autoScalaLibrary := false, + Compile / packageBin / artifactPath := + file( + "test/Exploratory_Benchmarks/polyglot/java/exploratory-benchmark-java-helpers.jar" + ), + libraryDependencies ++= Seq( + "org.graalvm.sdk" % "graal-sdk" % graalMavenPackagesVersion % "provided" + ) + ) + .dependsOn(`std-base` % "provided") + .dependsOn(`std-table` % "provided") + lazy val `std-table` = project .in(file("std-bits") / "table") .enablePlugins(Antlr4Plugin) @@ -2340,11 +2362,13 @@ pkgStdLibInternal := Def.inputTask { (`std-table` / Compile / packageBin).value case "TestHelpers" => (`enso-test-java-helpers` / Compile / packageBin).value + (`exploratory-benchmark-java-helpers` / Compile / packageBin).value case "AWS" => (`std-aws` / Compile / packageBin).value case _ if buildAllCmd => (`std-base` / Compile / packageBin).value (`enso-test-java-helpers` / Compile / packageBin).value + (`exploratory-benchmark-java-helpers` / Compile / packageBin).value (`std-table` / Compile / packageBin).value (`std-database` / Compile / packageBin).value (`std-image` / Compile / packageBin).value diff --git a/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Column.enso b/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Column.enso index 5253c1ad204..e324a4f0f3f 100644 --- a/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Column.enso +++ b/distribution/lib/Standard/Table/0.0.0-dev/src/Data/Column.enso @@ -47,8 +47,9 @@ type Column Column.from_vector "My Column" [1, 2, 3, 4, 5] from_vector : Text -> Vector -> Column from_vector name items = + expected_storage_type = Nothing Illegal_Argument.handle_java_exception <| - Column.Value (Java_Column.fromItems name items) + Column.Value (Java_Column.fromItems name items expected_storage_type) ## PRIVATE Creates a new column given a name and an internal Java storage. diff --git a/distribution/lib/Standard/Test/0.0.0-dev/src/Bench.enso b/distribution/lib/Standard/Test/0.0.0-dev/src/Bench.enso index 4afa325cef2..11bb3719b63 100644 --- a/distribution/lib/Standard/Test/0.0.0-dev/src/Bench.enso +++ b/distribution/lib/Standard/Test/0.0.0-dev/src/Bench.enso @@ -70,6 +70,15 @@ type Bench - label: A name for the measurement. - iter_size: The number of runs per iteration. - num_iters: The number of iterations per measurement. + - run_gc_between_iterations: Whether to try running the garbage collector + between iterations. Defaults to False. This is helpful when testing + memory intensive operations, to ensure that GC runs between iterations + and not _during_ iterations. The time taken to run the requested + garbage collection will not be counted into the iteration time, however + there is no guarantee that the JVM will actually accept the GC hint and + it is still possible the JVM may run GC during an iteration. But + setting this option to True should make it less likely for GC to + interrupt measurements. > Example Measure a computation called "foo" with an iteration size of 2 and a number @@ -80,8 +89,8 @@ type Bench example_measure = Bench.measure Examples.get_boolean "foo" iter_size=2 num_iters=1 - measure : Any -> Text -> Integer -> Integer -> Nothing - measure ~act label iter_size num_iters = + measure : Any -> Text -> Integer -> Integer -> Boolean -> Nothing + measure ~act label iter_size num_iters run_gc_between_iterations=False = dry_run = Environment.get "ENSO_BENCHMARK_TEST_DRY_RUN" "False" == "True" result = Ref.new 0.0 single_call = _ -> @@ -90,6 +99,8 @@ type Bench x2 = System.nano_time x2 - x1 iteration = it_size -> it_num -> + if run_gc_between_iterations then + Runtime.gc act_it_num = num_iters - it_num res = times it_size single_call avg = avg_list res diff --git a/std-bits/table/src/main/java/org/enso/table/data/table/Column.java b/std-bits/table/src/main/java/org/enso/table/data/table/Column.java index 709e944c0c6..a70fd54cb56 100644 --- a/std-bits/table/src/main/java/org/enso/table/data/table/Column.java +++ b/std-bits/table/src/main/java/org/enso/table/data/table/Column.java @@ -2,9 +2,11 @@ package org.enso.table.data.table; import org.enso.base.Text_Utils; import org.enso.base.polyglot.Polyglot_Utils; +import org.enso.table.data.column.builder.Builder; import org.enso.table.data.column.builder.InferredBuilder; import org.enso.table.data.column.storage.BoolStorage; import org.enso.table.data.column.storage.Storage; +import org.enso.table.data.column.storage.type.StorageType; import org.enso.table.data.index.DefaultIndex; import org.enso.table.data.index.Index; import org.enso.table.data.mask.OrderMask; @@ -116,18 +118,13 @@ public class Column { return new Column(name, storage); } - /** - * Creates a new column with given name and elements. - * - * @param name the name to use - * @param items the items contained in the column - * @return a column with given name and items - */ - public static Column fromItems(String name, List items) { + /** Creates a column from an Enso array, ensuring Enso dates are converted to Java dates. */ + public static Column fromItems(String name, List items, StorageType expectedType) throws ClassCastException { Context context = Context.getCurrent(); - InferredBuilder builder = new InferredBuilder(items.size()); + int n = items.size(); + Builder builder = expectedType == null ? new InferredBuilder(n) : Builder.getForType(expectedType, n); + // ToDo: This a workaround for an issue with polyglot layer. #5590 is related. - // to revert replace with: for (Value item : items) { for (Object item : items) { if (item instanceof Value v) { Object converted = Polyglot_Utils.convertPolyglotValue(v); @@ -142,6 +139,20 @@ public class Column { return new Column(name, storage); } + /** Creates a column from an Enso array. No polyglot conversion happens. This is unsafe */ + public static Column fromItemsNoDateConversion(String name, List items, StorageType expectedType) throws ClassCastException { + Context context = Context.getCurrent(); + int n = items.size(); + Builder builder = expectedType == null ? new InferredBuilder(n) : Builder.getForType(expectedType, n); + + for (Object item : items) { + builder.appendNoGrow(item); + context.safepoint(); + } + var storage = builder.seal(); + return new Column(name, storage); + } + /** * Creates a new column with given name and elements. * @@ -155,7 +166,7 @@ public class Column { } if (repeat == 1) { - return fromItems(name, items); + return fromItems(name, items, null); } Context context = Context.getCurrent(); diff --git a/test/Exploratory_Benchmarks/README.md b/test/Exploratory_Benchmarks/README.md new file mode 100644 index 00000000000..db88b914130 --- /dev/null +++ b/test/Exploratory_Benchmarks/README.md @@ -0,0 +1,52 @@ +# Exploring Table operation performance + +These benchmarks are used to compare various approaches to computing operations +on Table columns, to find out what best practices should we use for these and +find venues for optimization of the language and Table implementation. + +These benchmarks are not meant to be used for tracking performance of the +current implementation itself. That is supposed to be done by another project - +`Table_Benchmarks`. + +## Structure + +Currently, the benchmarks are split into a few files, each exploring some +separate topic, like mapping a single column, combining two columns with some +operation, or computing an aggregate operation over a column. In each file, +there may be a few Enso types, each representing a separate benchmark. Usually, +we have two benchmarks for each operation type - one dealing with a primitive +value type like integers (`long` in the Java side) and another dealing with a +reference type like `String` or `Date`. We expect the performance +characteristics between these may differ, e.g. because Java allows to use `long` +without boxing, so we compare them separately. + +Each Enso type for a given benchmark contains multiple methods which represent +various 'approaches' to computing the same operation. + +Each benchmark run has a name that consists of the type it defines it, a dot and +the method representing the particular approach, e.g. +`Boxed_Map_Test.enso_map_as_vector`. + +## Running + +The runner is very simple. If any options are to be customized, the Enso file +itself needs to be modified. One can run the whole project to run all the +benchmarks, or run only a specific file. + +## Analysis + +The output of the benchmarks should be saved to a file. Then that file can be +loaded using the Enso workflow in `tools/performance/benchmark-analysis`. + +The workflow is tuned to analysing these comparative benchmarks. + +At the top, one can select which file is to be analyzed. Below there is a +dropdown allowing to select one particular benchmark (represented by the type, +e.g. `Boxed_Map_Test`). With that selected, one can display a scatter plot +visualization comparing various approaches of that one given benchmark. On the +plot we can see runtimes of subsequent iterations. Later, we drop the first 40 +iterations (the number can easily be customized in the workflow) to ensure +sufficient warm-up for each benchmark. Then a table is displayed computing the +average runtime of each approach and how they compare relative to each other - a +dropdown allows to select one benchmark that will be used as a reference point +(100%) for the average runtime comparison. diff --git a/test/Exploratory_Benchmarks/package.yaml b/test/Exploratory_Benchmarks/package.yaml new file mode 100644 index 00000000000..5647e2086e4 --- /dev/null +++ b/test/Exploratory_Benchmarks/package.yaml @@ -0,0 +1,6 @@ +name: Exploratory_Benchmarks +enso-version: default +version: 0.0.1 +license: MIT +author: enso-dev@enso.org +maintainer: enso-dev@enso.org diff --git a/test/Exploratory_Benchmarks/polyglot-sources/exploratory-benchmark-java-helpers/src/main/java/org/enso/exploratory_benchmark_helpers/MapHelpers.java b/test/Exploratory_Benchmarks/polyglot-sources/exploratory-benchmark-java-helpers/src/main/java/org/enso/exploratory_benchmark_helpers/MapHelpers.java new file mode 100644 index 00000000000..519871bf52a --- /dev/null +++ b/test/Exploratory_Benchmarks/polyglot-sources/exploratory-benchmark-java-helpers/src/main/java/org/enso/exploratory_benchmark_helpers/MapHelpers.java @@ -0,0 +1,109 @@ +package org.enso.exploratory_benchmark_helpers; + +import java.util.BitSet; +import java.util.function.Function; +import org.enso.base.Text_Utils; +import org.enso.table.data.column.builder.Builder; +import org.enso.table.data.column.builder.InferredBuilder; +import org.enso.table.data.column.storage.BoolStorage; +import org.enso.table.data.column.storage.Storage; +import org.enso.table.data.column.storage.StringStorage; +import org.enso.table.data.column.storage.datetime.DateStorage; +import org.enso.table.data.column.storage.numeric.LongStorage; +import org.enso.table.data.column.storage.type.StorageType; + +public class MapHelpers { + public static StringStorage stringConcatBimap(StringStorage storage1, StringStorage storage2) { + if (storage1.size() != storage2.size()) { + throw new IllegalArgumentException("Storage sizes must match"); + } + + int n = storage1.size(); + String[] result = new String[n]; + for (int i = 0; i < n; i++) { + if (!storage1.isNa(i) && !storage2.isNa(i)) { + result[i] = storage1.getItem(i) + storage2.getItem(i); + } else { + result[i] = null; + } + } + return new StringStorage(result, n); + } + + public static LongStorage longAddBimap(LongStorage storage1, LongStorage storage2) { + if (storage1.size() != storage2.size()) { + throw new IllegalArgumentException("Storage sizes must match"); + } + + int n = storage1.size(); + long[] result = new long[n]; + BitSet missing = new BitSet(); + for (int i = 0; i < n; i++) { + if (!storage1.isNa(i) && !storage2.isNa(i)) { + result[i] = storage1.getItem(i) + storage2.getItem(i); + } else { + missing.set(i); + } + } + return new LongStorage(result, n, missing); + } + + public static BoolStorage textEndsWith(StringStorage storage, String suffix) { + int n = storage.size(); + BitSet result = new BitSet(); + BitSet missing = new BitSet(); + for (int i = 0; i < n; i++) { + if (storage.isNa(i)) { + missing.set(i); + } else { + if (Text_Utils.ends_with(storage.getItem(i), suffix)) { + result.set(i); + } + } + } + return new BoolStorage(result, missing, n, false); + } + + public static LongStorage longAdd(LongStorage storage, long shift) { + int n = storage.size(); + long[] result = new long[n]; + BitSet missing = new BitSet(); + for (int i = 0; i < n; i++) { + if (!storage.isNa(i)) { + result[i] = storage.getItem(i) + shift; + } else { + missing.set(i); + } + } + return new LongStorage(result, n, missing); + } + + public static LongStorage getYear(DateStorage storage) { + int n = storage.size(); + long[] result = new long[n]; + BitSet missing = new BitSet(); + for (int i = 0; i < n; i++) { + if (!storage.isNa(i)) { + result[i] = storage.getItem(i).getYear(); + } else { + missing.set(i); + } + } + return new LongStorage(result, n, missing); + } + + public static Storage mapCallback( + Storage storage, Function fn, StorageType expectedType) { + int n = storage.size(); + Builder builder = + expectedType == null ? new InferredBuilder(n) : Builder.getForType(expectedType, n); + for (int i = 0; i < n; i++) { + if (!storage.isNa(i)) { + builder.append(fn.apply(storage.getItemBoxed(i))); + } else { + builder.appendNulls(1); + } + } + return builder.seal(); + } +} diff --git a/test/Exploratory_Benchmarks/polyglot-sources/exploratory-benchmark-java-helpers/src/main/java/org/enso/exploratory_benchmark_helpers/SimpleStorageAggregateHelpers.java b/test/Exploratory_Benchmarks/polyglot-sources/exploratory-benchmark-java-helpers/src/main/java/org/enso/exploratory_benchmark_helpers/SimpleStorageAggregateHelpers.java new file mode 100644 index 00000000000..8c2f2172edb --- /dev/null +++ b/test/Exploratory_Benchmarks/polyglot-sources/exploratory-benchmark-java-helpers/src/main/java/org/enso/exploratory_benchmark_helpers/SimpleStorageAggregateHelpers.java @@ -0,0 +1,46 @@ +package org.enso.exploratory_benchmark_helpers; + +import java.time.LocalDate; +import org.enso.base.Text_Utils; +import org.enso.table.data.column.storage.StringStorage; +import org.enso.table.data.column.storage.datetime.DateStorage; +import org.enso.table.data.column.storage.numeric.LongStorage; + +public class SimpleStorageAggregateHelpers { + public static long sumLongStorage(LongStorage storage) { + long sum = 0; + for (int i = 0; i < storage.size(); i++) { + if (!storage.isNa(i)) { + sum += storage.getItem(i); + } + } + return sum; + } + + public static long sumMonthsOfDateStorage(DateStorage storage) { + long sum = 0; + for (LocalDate date : storage.getData()) { + if (date != null) { + sum += date.getMonthValue(); + } + } + return sum; + } + + public static String longestText(StringStorage storage) { + long longest = -1; + String longestText = null; + int n = storage.size(); + for (int i = 0; i < n; i++) { + if (!storage.isNa(i)) { + String text = storage.getItem(i); + long length = Text_Utils.grapheme_length(text); + if (length > longest) { + longest = length; + longestText = text; + } + } + } + return longestText; + } +} diff --git a/test/Exploratory_Benchmarks/src/Main.enso b/test/Exploratory_Benchmarks/src/Main.enso new file mode 100644 index 00000000000..18af0e8551d --- /dev/null +++ b/test/Exploratory_Benchmarks/src/Main.enso @@ -0,0 +1,3 @@ +import project.Table.Main as Table_Main + +main = Table_Main.spec diff --git a/test/Exploratory_Benchmarks/src/Table/Column_Aggregate.enso b/test/Exploratory_Benchmarks/src/Table/Column_Aggregate.enso new file mode 100644 index 00000000000..edb13251e93 --- /dev/null +++ b/test/Exploratory_Benchmarks/src/Table/Column_Aggregate.enso @@ -0,0 +1,127 @@ +from Standard.Base import all +from Standard.Table import all + +from Standard.Test import Bench + +import project.Table.Common_Setup.Common_Setup +import project.Table.Helpers + +polyglot java import org.enso.exploratory_benchmark_helpers.SimpleStorageAggregateHelpers + +## Computes the Longest text in the column - aggregate with no grouping. + This is of interest, because in contrast to all benchmarks above, it can generally be done in O(1) memory. +type Boxed_Total_Aggregate + Instance text_column + + current_aggregate_implementation self = + self.text_column.to_table.aggregate [Aggregate_Column.Longest 0] . at 0 . at 0 + + java_loop self = + SimpleStorageAggregateHelpers.longestText self.text_column.java_column.getStorage + + enso_aggregate_vector_proxy self = + n = self.text_column.length + vector_proxy = self.text_column.to_vector + (0.up_to n).fold Nothing acc-> ix-> + item = vector_proxy.at ix + if acc.is_nothing then item else + if item.is_nothing then acc else + if item.length > acc.length then item else acc + + enso_aggregate_storage_get_item self = + n = self.text_column.length + storage = self.text_column.java_column.getStorage + (0.up_to n).fold Nothing acc-> ix-> + item = storage.getItemBoxed ix + if acc.is_nothing then item else + if item.is_nothing then acc else + if item.length > acc.length then item else acc + + verify_correctness self = + Helpers.check_results [self.current_aggregate_implementation, self.java_loop, self.enso_aggregate_vector_proxy, self.enso_aggregate_storage_get_item] + +## Computes Sum of integers. + We have to be careful with `n` because if we use too large values Enso will start using BigInts, while Java will overflow. +type Primitive_Total_Aggregate + Instance int_column + + current_aggregate_implementation self = + self.int_column.to_table.aggregate [Aggregate_Column.Sum 0] . at 0 . at 0 + + java_loop self = + long_storage = self.int_column.java_column.getStorage + SimpleStorageAggregateHelpers.sumLongStorage long_storage + + enso_aggregate_vector_proxy self = + vector_proxy = self.int_column.to_vector + vector_proxy.fold 0 acc-> item-> + if item.is_nothing then acc else + acc + item + + enso_aggregate_storage_get_item self = + n = self.int_column.length + storage = self.int_column.java_column.getStorage + (0.up_to n).fold 0 acc-> ix-> + if storage.isNa ix then acc else + acc + storage.getItem ix + + verify_correctness self = + Helpers.check_results [self.current_aggregate_implementation, self.java_loop, self.enso_aggregate_vector_proxy, self.enso_aggregate_storage_get_item] + +## An alternative to Boxed_Total_Aggregate. Computing text length is complex due + to ICU complexity. This is a simpler one - we get the month of each value and + sum these. +type Boxed_Sum_Months + Instance date_column + + java_loop self = + date_storage = self.date_column.java_column.getStorage + SimpleStorageAggregateHelpers.sumMonthsOfDateStorage date_storage + + enso_aggregate_vector_proxy self = + vector_proxy = self.date_column.to_vector + vector_proxy.fold 0 acc-> item-> + if item.is_nothing then acc else + acc + item.month + + enso_aggregate_storage_get_item self = + n = self.date_column.length + storage = self.date_column.java_column.getStorage + (0.up_to n).fold 0 acc-> ix-> + item = storage.getItemBoxed ix + if item.is_nothing then acc else + acc + item.month + + verify_correctness self = + Helpers.check_results [self.java_loop, self.enso_aggregate_vector_proxy, self.enso_aggregate_storage_get_item] + +main = spec (Common_Setup.Config) + +spec setup = + t = setup.generate_input_table + t2 = setup.generate_input_table_date + + iter_size = setup.iter_size + num_iterations = setup.num_iterations + + # Using ints2 to get smaller values to avoid integer overflow. + primitive_total_aggregate = Primitive_Total_Aggregate.Instance (t.at "ints2") + primitive_total_aggregate.verify_correctness + # GC not needed here as this should be O(1) memory. + Bench.measure (primitive_total_aggregate.current_aggregate_implementation) "Primitive_Total_Aggregate.current_aggregate_implementation" iter_size num_iterations run_gc_between_iterations=False + Bench.measure (primitive_total_aggregate.java_loop) "Primitive_Total_Aggregate.java_loop" iter_size num_iterations run_gc_between_iterations=False + Bench.measure (primitive_total_aggregate.enso_aggregate_vector_proxy) "Primitive_Total_Aggregate.enso_aggregate_vector_proxy" iter_size num_iterations run_gc_between_iterations=False + Bench.measure (primitive_total_aggregate.enso_aggregate_storage_get_item) "Primitive_Total_Aggregate.enso_aggregate_storage_get_item" iter_size num_iterations run_gc_between_iterations=False + + boxed_sum_months = Boxed_Sum_Months.Instance (t2.at "dates") + boxed_sum_months.verify_correctness + Bench.measure (boxed_sum_months.java_loop) "Boxed_Sum_Months.java_loop" iter_size num_iterations run_gc_between_iterations=False + Bench.measure (boxed_sum_months.enso_aggregate_vector_proxy) "Boxed_Sum_Months.enso_aggregate_vector_proxy" iter_size num_iterations run_gc_between_iterations=False + Bench.measure (boxed_sum_months.enso_aggregate_storage_get_item) "Boxed_Sum_Months.enso_aggregate_storage_get_item" iter_size num_iterations run_gc_between_iterations=False + + boxed_total_aggregate = Boxed_Total_Aggregate.Instance (t.at "text") + boxed_total_aggregate.verify_correctness + Bench.measure (boxed_total_aggregate.current_aggregate_implementation) "Boxed_Total_Aggregate.current_aggregate_implementation" iter_size num_iterations run_gc_between_iterations=False + Bench.measure (boxed_total_aggregate.java_loop) "Boxed_Total_Aggregate.java_loop" iter_size num_iterations run_gc_between_iterations=False + Bench.measure (boxed_total_aggregate.enso_aggregate_vector_proxy) "Boxed_Total_Aggregate.enso_aggregate_vector_proxy" iter_size num_iterations run_gc_between_iterations=False + Bench.measure (boxed_total_aggregate.enso_aggregate_storage_get_item) "Boxed_Total_Aggregate.enso_aggregate_storage_get_item" iter_size num_iterations run_gc_between_iterations=False diff --git a/test/Exploratory_Benchmarks/src/Table/Column_Bi_Map.enso b/test/Exploratory_Benchmarks/src/Table/Column_Bi_Map.enso new file mode 100644 index 00000000000..923c27f3dd9 --- /dev/null +++ b/test/Exploratory_Benchmarks/src/Table/Column_Bi_Map.enso @@ -0,0 +1,104 @@ +from Standard.Base import all +from Standard.Table import all + +from Standard.Test import Bench + +import project.Table.Common_Setup.Common_Setup +import project.Table.Helpers + +polyglot java import org.enso.exploratory_benchmark_helpers.MapHelpers +polyglot java import org.enso.table.data.column.builder.NumericBuilder +polyglot java import org.enso.table.data.column.builder.StringBuilder + +# Adding two String columns +type Boxed_Bi_Map_Test + Instance text_column_1 text_column_2 + + current_implementation self = + self.text_column_1 + self.text_column_2 + + java_map self = + Column.from_storage "result" <| + MapHelpers.stringConcatBimap self.text_column_1.java_column.getStorage self.text_column_2.java_column.getStorage + + enso_map_as_vector self convert_polyglot_dates = + vector_proxy_1 = self.text_column_1.to_vector + vector_proxy_2 = self.text_column_2.to_vector + mapped = vector_proxy_1.zip vector_proxy_2 (+) + Helpers.column_from_vector "result" mapped convert_polyglot_dates=convert_polyglot_dates + + enso_map_with_builder self = + n = self.text_column_1.length + if self.text_column_2.length != n then Panic.throw "LENGTH MISMATCH" else + builder = StringBuilder.new n + storage_1 = self.text_column_1.java_column.getStorage + storage_2 = self.text_column_2.java_column.getStorage + 0.up_to n . each i-> + item_1 = storage_1.getItemBoxed i + item_2 = storage_2.getItemBoxed i + if item_1.is_nothing || item_2.is_nothing then builder.appendNulls 1 else + res = item_1 + item_2 + builder.append res + Column.from_storage "result" builder.seal + + verify_correctness self = + Helpers.check_results [self.current_implementation, self.java_map, self.enso_map_as_vector convert_polyglot_dates=True, self.enso_map_as_vector convert_polyglot_dates=False, self.enso_map_with_builder] + +# Adding two Long columns +type Primitive_Bi_Map_Test + Instance int_column_1 int_column_2 + + current_implementation self = + self.int_column_1 + self.int_column_2 + + java_map self = + Column.from_storage "result" <| + MapHelpers.longAddBimap self.int_column_1.java_column.getStorage self.int_column_2.java_column.getStorage + + enso_map_as_vector self convert_polyglot_dates = + vector_proxy_1 = self.int_column_1.to_vector + vector_proxy_2 = self.int_column_2.to_vector + mapped = vector_proxy_1.zip vector_proxy_2 (+) + Helpers.column_from_vector "result" mapped convert_polyglot_dates=convert_polyglot_dates + + enso_map_with_builder self = + n = self.int_column_1.length + if self.int_column_2.length != n then Panic.throw "LENGTH MISMATCH" else + builder = NumericBuilder.createLongBuilder n + storage_1 = self.int_column_1.java_column.getStorage + storage_2 = self.int_column_2.java_column.getStorage + 0.up_to n . each i-> + if storage_1.isNa i || storage_2.isNa i then builder.appendNulls 1 else + item_1 = storage_1.getItem i + item_2 = storage_2.getItem i + res = item_1 + item_2 + builder.appendLong res + Column.from_storage "result" builder.seal + + verify_correctness self = + Helpers.check_results [self.current_implementation, self.java_map, self.enso_map_as_vector convert_polyglot_dates=True, self.enso_map_as_vector convert_polyglot_dates=False, self.enso_map_with_builder] + +main = spec Common_Setup.Config + +spec setup = + t = setup.generate_input_table + + iter_size = setup.iter_size + num_iterations = setup.num_iterations + should_run_gc = setup.force_gc + + primitive_bimap = Primitive_Bi_Map_Test.Instance (t.at "ints") (t.at "ints2") + primitive_bimap.verify_correctness + Bench.measure (primitive_bimap.current_implementation) "Primitive_Bi_Map_Test.current_implementation" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_bimap.java_map) "Primitive_Bi_Map_Test.java_map" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_bimap.enso_map_as_vector convert_polyglot_dates=True) "Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_bimap.enso_map_as_vector convert_polyglot_dates=False) "Primitive_Bi_Map_Test.enso_map_as_vector" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_bimap.enso_map_with_builder) "Primitive_Bi_Map_Test.enso_map_with_builder" iter_size num_iterations run_gc_between_iterations=should_run_gc + + boxed_bimap = Boxed_Bi_Map_Test.Instance (t.at "text") (t.at "text2") + boxed_bimap.verify_correctness + Bench.measure (boxed_bimap.current_implementation) "Boxed_Bi_Map_Test.current_implementation" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_bimap.java_map) "Boxed_Bi_Map_Test.java_map" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_bimap.enso_map_as_vector convert_polyglot_dates=True) "Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_bimap.enso_map_as_vector convert_polyglot_dates=False) "Boxed_Bi_Map_Test.enso_map_as_vector" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_bimap.enso_map_with_builder) "Boxed_Bi_Map_Test.enso_map_with_builder" iter_size num_iterations run_gc_between_iterations=should_run_gc diff --git a/test/Exploratory_Benchmarks/src/Table/Column_Map.enso b/test/Exploratory_Benchmarks/src/Table/Column_Map.enso new file mode 100644 index 00000000000..9a88ae2c8fe --- /dev/null +++ b/test/Exploratory_Benchmarks/src/Table/Column_Map.enso @@ -0,0 +1,111 @@ +from Standard.Base import all +from Standard.Table import all + +from Standard.Test import Bench + +import project.Table.Common_Setup.Common_Setup +import project.Table.Helpers + +polyglot java import org.enso.exploratory_benchmark_helpers.MapHelpers +polyglot java import org.enso.table.data.column.builder.BoolBuilder +polyglot java import org.enso.table.data.column.builder.NumericBuilder + +## This tests an operation on a boxed value (e.g. ends_with on a String). + It is the basic benchmark for comparing the performance between the vectorized Java op and approaches relying on Enso. + We would like to see the Enso approach to have comparable performance to the Java one. +type Boxed_Map_Test + Instance text_column (suffix : Text) + + current_implementation self = + self.text_column.ends_with self.suffix + + java_map self = + Column.from_storage "result" <| + MapHelpers.textEndsWith self.text_column.java_column.getStorage self.suffix + + enso_map_as_vector self convert_polyglot_dates = + suffix = self.suffix + vector_proxy = self.text_column.to_vector + mapped = vector_proxy.map x-> x.ends_with suffix + Helpers.column_from_vector "result" mapped convert_polyglot_dates=convert_polyglot_dates + + enso_map_with_builder self = + suffix = self.suffix + n = self.text_column.length + builder = BoolBuilder.new n + storage = self.text_column.java_column.getStorage + 0.up_to n . each i-> + item = storage.getItemBoxed i + case item of + Nothing -> + builder.appendNulls 1 + _ -> + b = item.ends_with suffix + builder.appendBoolean b + Column.from_storage "result" builder.seal + + verify_correctness self = + Helpers.check_results [self.current_implementation, self.java_map, self.enso_map_as_vector convert_polyglot_dates=True, self.enso_map_as_vector convert_polyglot_dates=False, self.enso_map_with_builder] + +## This tests an operation on a primitive value, that in Java is stored as unboxed (e.g. + on LongStorage). + This is a more demanding benchmark, because the Java side has an advantage of easily using the unboxed values everywhere. + Here it may be harder to achieve comparable performance, but we want to know what is the difference, and ideally we want to be getting closer here as well. +type Primitive_Map_Test + Instance int_column (shift : Integer) + + current_implementation self = + self.int_column + self.shift + + java_map self = + Column.from_storage "result" <| + MapHelpers.longAdd self.int_column.java_column.getStorage self.shift + + enso_map_as_vector self convert_polyglot_dates = + shift = self.shift + vector_proxy = self.int_column.to_vector + mapped = vector_proxy.map x-> x + shift + Helpers.column_from_vector "result" mapped convert_polyglot_dates=convert_polyglot_dates + + enso_map_with_builder self = + shift = self.shift + n = self.int_column.length + builder = NumericBuilder.createLongBuilder n + storage = self.int_column.java_column.getStorage + 0.up_to n . each i-> + case storage.isNa i of + True -> + builder.appendNulls 1 + False -> + item = storage.getItem i + x = item + shift + builder.appendLong x + Column.from_storage "result" builder.seal + + verify_correctness self = + Helpers.check_results [self.current_implementation, self.java_map, self.enso_map_as_vector convert_polyglot_dates=True, self.enso_map_as_vector convert_polyglot_dates=False, self.enso_map_with_builder] + +main = spec Common_Setup.Config + +spec setup = + t = setup.generate_input_table + + iter_size = setup.iter_size + num_iterations = setup.num_iterations + should_run_gc = setup.force_gc + + primitive_map = Primitive_Map_Test.Instance (t.at "ints") 42 + primitive_map.verify_correctness + Bench.measure (primitive_map.current_implementation) "Primitive_Map_Test.current_implementation" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_map.java_map) "Primitive_Map_Test.java_map" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_map.enso_map_as_vector convert_polyglot_dates=True) "Primitive_Map_Test.enso_map_as_vector+convert_dates" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_map.enso_map_as_vector convert_polyglot_dates=False) "Primitive_Map_Test.enso_map_as_vector" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_map.enso_map_with_builder) "Primitive_Map_Test.enso_map_with_builder" iter_size num_iterations run_gc_between_iterations=should_run_gc + + # This one seems slowest so I put it at the end. + boxed_map = Boxed_Map_Test.Instance (t.at "text") "5" + boxed_map.verify_correctness + Bench.measure (boxed_map.current_implementation) "Boxed_Map_Test.current_implementation" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_map.java_map) "Boxed_Map_Test.java_map" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_map.enso_map_as_vector convert_polyglot_dates=True) "Boxed_Map_Test.enso_map_as_vector+convert_dates" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_map.enso_map_as_vector convert_polyglot_dates=False) "Boxed_Map_Test.enso_map_as_vector" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_map.enso_map_with_builder) "Boxed_Map_Test.enso_map_with_builder" iter_size num_iterations run_gc_between_iterations=should_run_gc diff --git a/test/Exploratory_Benchmarks/src/Table/Column_Map_2.enso b/test/Exploratory_Benchmarks/src/Table/Column_Map_2.enso new file mode 100644 index 00000000000..fcdab2c02c8 --- /dev/null +++ b/test/Exploratory_Benchmarks/src/Table/Column_Map_2.enso @@ -0,0 +1,77 @@ +from Standard.Base import all +from Standard.Table import all + +from Standard.Test import Bench + +import project.Table.Common_Setup.Common_Setup +import project.Table.Helpers + +polyglot java import org.enso.exploratory_benchmark_helpers.MapHelpers +polyglot java import org.enso.table.data.column.builder.NumericBuilder + +## A second variant of Boxed_Map_Test. + The first one relied on `ends_with` which is actually a costly operation due to reliance on ICU and correct grapheme cluster handling. + So as a second comparison we will do `Date.year` instead which is much simpler. +type Boxed_Map_Test_2 + Instance date_column + + current_implementation self = + self.date_column.year + + java_map self = + Column.from_storage "result" <| + MapHelpers.getYear self.date_column.java_column.getStorage + + ## We can still opt-out of `convert_polyglot_dates`, because this is applied + at output which is Integer. If our output was another Date, we could not + opt-out to remain correct. + enso_map_as_vector self convert_polyglot_dates = + vector_proxy = self.date_column.to_vector + mapped = vector_proxy.map x-> x.year + Helpers.column_from_vector "result" mapped convert_polyglot_dates=convert_polyglot_dates + + enso_map_with_builder_append_long self = + n = self.date_column.length + builder = NumericBuilder.createLongBuilder n + storage = self.date_column.java_column.getStorage + 0.up_to n . each i-> + case storage.getItemBoxed i of + Nothing -> + builder.appendNulls 1 + date -> + builder.appendLong date.year + Column.from_storage "result" builder.seal + + ## This is the same as above, but uses `appendNoGrow` instead of + `appendLong`. I suspect it could be more efficient, so I'm testing it. + enso_map_with_builder_append_object self = + n = self.date_column.length + builder = NumericBuilder.createLongBuilder n + storage = self.date_column.java_column.getStorage + 0.up_to n . each i-> + case storage.getItemBoxed i of + Nothing -> + builder.appendNulls 1 + date -> + builder.appendNoGrow date.year + Column.from_storage "result" builder.seal + + verify_correctness self = + Helpers.check_results [self.current_implementation, self.java_map, self.enso_map_as_vector convert_polyglot_dates=True, self.enso_map_as_vector convert_polyglot_dates=False, self.enso_map_with_builder_append_long, self.enso_map_with_builder_append_object] + +main = spec (Common_Setup.Config) + +spec setup = + t = setup.generate_input_table_date + + iter_size = setup.iter_size + num_iterations = setup.num_iterations + should_run_gc = setup.force_gc + + boxed_map = Boxed_Map_Test_2.Instance (t.at "dates") + Bench.measure (boxed_map.current_implementation) "Boxed_Map_Test_2.current_implementation" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_map.java_map) "Boxed_Map_Test_2.java_map" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_map.enso_map_as_vector convert_polyglot_dates=True) "Boxed_Map_Test_2.enso_map_as_vector+convert_dates" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_map.enso_map_as_vector convert_polyglot_dates=False) "Boxed_Map_Test_2.enso_map_as_vector" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_map.enso_map_with_builder_append_long) "Boxed_Map_Test_2.enso_map_with_builder_append_long" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_map.enso_map_with_builder_append_object) "Boxed_Map_Test_2.enso_map_with_builder_append_object" iter_size num_iterations run_gc_between_iterations=should_run_gc diff --git a/test/Exploratory_Benchmarks/src/Table/Common_Setup.enso b/test/Exploratory_Benchmarks/src/Table/Common_Setup.enso new file mode 100644 index 00000000000..6482a72435f --- /dev/null +++ b/test/Exploratory_Benchmarks/src/Table/Common_Setup.enso @@ -0,0 +1,19 @@ +from Standard.Base import all +from Standard.Table import all + +type Common_Setup + Config (n : Integer = 10^6) (iter_size : Integer = 1) (num_iterations : Integer = 100) (force_gc : Boolean = False) + + generate_input_table : Table + generate_input_table self = + n = self.n + v1 = (0.up_to n).to_vector + v2 = (0.up_to n).to_vector.reverse.map (x-> x % 20) + Table.new [["ints", v1], ["text", v1.map .to_text], ["ints2", v2], ["text2", v2.map .to_text]] + + generate_input_table_date : Table + generate_input_table_date self = + n = self.n + v1 = (0.up_to n).map i-> + (Date.new 1999 1 1) . date_add i Date_Period.Day + Table.new [["dates", v1]] diff --git a/test/Exploratory_Benchmarks/src/Table/Enso_Callback.enso b/test/Exploratory_Benchmarks/src/Table/Enso_Callback.enso new file mode 100644 index 00000000000..8b6f162b4ae --- /dev/null +++ b/test/Exploratory_Benchmarks/src/Table/Enso_Callback.enso @@ -0,0 +1,140 @@ +from Standard.Base import all + +from Standard.Table import all +import Standard.Table.Data.Type.Storage + +from Standard.Test import Bench + +import project.Table.Common_Setup.Common_Setup +import project.Table.Helpers + +polyglot java import org.enso.exploratory_benchmark_helpers.MapHelpers +polyglot java import org.enso.table.data.column.builder.StringBuilder +polyglot java import org.enso.table.data.column.builder.NumericBuilder +polyglot java import org.enso.table.data.column.operation.map.MapOperationProblemBuilder +polyglot java import org.enso.table.data.table.Column as Java_Column + +## This tests an operation that executes an Enso function on each element of a column. + It is meant to compare the cost of calling-back into Enso from Java vs staying in Enso. +type Boxed_Enso_Callback_Test + Instance text_column (fn : Text -> Text) + + current_implementation self = + self.text_column.map self.fn + + java_roundtrip self = + expected_type = Storage.from_value_type_strict Value_Type.Char + Column.from_storage "result" <| + MapHelpers.mapCallback self.text_column.java_column.getStorage self.fn expected_type + + enso_map_as_vector self convert_polyglot_dates = + vector_proxy = self.text_column.to_vector + mapped = vector_proxy.map self.fn + Helpers.column_from_vector "result" mapped convert_polyglot_dates=convert_polyglot_dates + + enso_map_with_builder self = + n = self.text_column.length + fn = self.fn + builder = StringBuilder.new n + storage = self.text_column.java_column.getStorage + 0.up_to n . each i-> + case storage.getItemBoxed i of + Nothing -> + builder.appendNulls 1 + item -> + builder.append (fn item) + Column.from_storage "result" builder.seal + + verify_correctness self = + Helpers.check_results [self.current_implementation, self.java_roundtrip, self.enso_map_as_vector convert_polyglot_dates=True, self.enso_map_as_vector convert_polyglot_dates=False, self.enso_map_with_builder] + +## This variant checks how a primitive type column will behave. +type Primitive_Enso_Callback_Test + Instance int_column (shift : Integer) + + fn self = + shift = self.shift + x-> x + shift + + current_implementation_as_map self = + self.int_column.map self.fn + + java_vectorized self = + Column.from_storage "result" <| + MapHelpers.longAdd self.int_column.java_column.getStorage self.shift + + java_roundtrip self = + expected_type = Storage.from_value_type_strict Value_Type.Integer + Column.from_storage "result" <| + MapHelpers.mapCallback self.int_column.java_column.getStorage self.fn expected_type + + enso_map_as_vector_inferred_builder self convert_polyglot_dates = + vector_proxy = self.int_column.to_vector + mapped = vector_proxy.map self.fn + Helpers.column_from_vector "result" mapped convert_polyglot_dates=convert_polyglot_dates + + enso_map_as_vector_long_builder self = + vector_proxy = self.int_column.to_vector + mapped = vector_proxy.map self.fn + # No expected storage will use inferred builder. + expected_storage_type = Storage.from_value_type_strict Value_Type.Integer + Column.Value (Java_Column.fromItemsNoDateConversion "result" mapped expected_storage_type) + + enso_map_with_builder_2_calls_unboxed self = + n = self.int_column.length + fn = self.fn + builder = NumericBuilder.createLongBuilder n + storage = self.int_column.java_column.getStorage + 0.up_to n . each i-> + case storage.isNa i of + True -> + builder.appendNulls 1 + False -> + item = storage.getItem i + builder.append (fn item) + Column.from_storage "result" builder.seal + + enso_map_with_builder_1_call_boxed self = + n = self.int_column.length + fn = self.fn + builder = NumericBuilder.createLongBuilder n + storage = self.int_column.java_column.getStorage + 0.up_to n . each i-> + case storage.getItemBoxed i of + Nothing -> + builder.appendNulls 1 + item -> + builder.append (fn item) + Column.from_storage "result" builder.seal + + verify_correctness self = + Helpers.check_results [self.current_implementation_as_map, self.java_vectorized, self.java_roundtrip, self.enso_map_as_vector_inferred_builder convert_polyglot_dates=True, self.enso_map_as_vector_inferred_builder convert_polyglot_dates=False, self.enso_map_as_vector_long_builder, self.enso_map_with_builder_2_calls_unboxed, self.enso_map_with_builder_1_call_boxed] + +main = spec (Common_Setup.Config) + +spec setup = + t = setup.generate_input_table + + iter_size = setup.iter_size + num_iterations = setup.num_iterations + should_run_gc = setup.force_gc + + primitive_callback_test = Primitive_Enso_Callback_Test.Instance (t.at "ints") 42 + primitive_callback_test.verify_correctness + Bench.measure (primitive_callback_test.current_implementation_as_map) "Primitive_Enso_Callback_Test.current_implementation_as_map" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_callback_test.java_vectorized) "Primitive_Enso_Callback_Test.java_vectorized" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_callback_test.java_roundtrip) "Primitive_Enso_Callback_Test.java_roundtrip" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_callback_test.enso_map_as_vector_inferred_builder convert_polyglot_dates=False) "Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_callback_test.enso_map_as_vector_inferred_builder convert_polyglot_dates=True) "Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_callback_test.enso_map_as_vector_long_builder) "Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_callback_test.enso_map_with_builder_2_calls_unboxed) "Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (primitive_callback_test.enso_map_with_builder_1_call_boxed) "Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed" iter_size num_iterations run_gc_between_iterations=should_run_gc + + fn x = "|" + x + "|" + boxed_callback_test = Boxed_Enso_Callback_Test.Instance (t.at "text") fn + boxed_callback_test.verify_correctness + Bench.measure (boxed_callback_test.current_implementation) "Boxed_Enso_Callback_Test.current_implementation" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_callback_test.java_roundtrip) "Boxed_Enso_Callback_Test.java_roundtrip" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_callback_test.enso_map_as_vector convert_polyglot_dates=False) "Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_callback_test.enso_map_as_vector convert_polyglot_dates=True) "Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion" iter_size num_iterations run_gc_between_iterations=should_run_gc + Bench.measure (boxed_callback_test.enso_map_with_builder) "Boxed_Enso_Callback_Test.enso_map_with_builder" iter_size num_iterations run_gc_between_iterations=should_run_gc diff --git a/test/Exploratory_Benchmarks/src/Table/Helpers.enso b/test/Exploratory_Benchmarks/src/Table/Helpers.enso new file mode 100644 index 00000000000..53a44fab321 --- /dev/null +++ b/test/Exploratory_Benchmarks/src/Table/Helpers.enso @@ -0,0 +1,34 @@ +from Standard.Base import all +import Standard.Base.Errors.Illegal_Argument.Illegal_Argument +import Standard.Base.Errors.Illegal_State.Illegal_State + +from Standard.Table import all + +polyglot java import org.enso.table.data.table.Column as Java_Column + +## PRIVATE + A helper implementation essentially mimicking Column.from_vector, but + allowing to control whether polyglot conversions are performed. + Used to make tests stable regardless of changes to Column.from_vector. +column_from_vector : Text -> Vector -> Boolean -> Column +column_from_vector name items convert_polyglot_dates = + expected_storage_type = Nothing + Illegal_Argument.handle_java_exception <| + java_column = case convert_polyglot_dates of + True -> + Java_Column.fromItems name items expected_storage_type + False -> + Java_Column.fromItemsNoDateConversion name items expected_storage_type + Column.Value java_column + +check_results results = + mapped = results.map x-> case x of + _ : Column -> x.to_vector + _ -> x + reference = mapped.first + mapped.each_with_index ix-> result-> + if result != reference then + IO.println "Mismatched results: " + IO.println "Reference: "+reference.to_display_text + IO.println "Result (ix="+ix.to_text+"): "+result.to_display_text + Panic.throw (Illegal_State.Error "The benchmark result ix="+ix.to_text+" does not match the 0th one.") diff --git a/test/Exploratory_Benchmarks/src/Table/Main.enso b/test/Exploratory_Benchmarks/src/Table/Main.enso new file mode 100644 index 00000000000..89175eb4cde --- /dev/null +++ b/test/Exploratory_Benchmarks/src/Table/Main.enso @@ -0,0 +1,19 @@ +## NOTE + This file is _not_ automatically run when the benchmarks are run. + It can be used to run all performance tests in a single run. +import project.Table.Column_Aggregate +import project.Table.Column_Bi_Map +import project.Table.Column_Map +import project.Table.Column_Map_2 +import project.Table.Common_Setup.Common_Setup +import project.Table.Enso_Callback + +spec = + setup = (Common_Setup.Config) + Column_Map.spec setup + Column_Map_2.spec setup + Column_Bi_Map.spec setup + Column_Aggregate.spec setup + Enso_Callback.spec setup + +main = spec diff --git a/tools/performance/benchmark-analysis/README.md b/tools/performance/benchmark-analysis/README.md new file mode 100644 index 00000000000..3b584fb2532 --- /dev/null +++ b/tools/performance/benchmark-analysis/README.md @@ -0,0 +1,5 @@ +# Analysing benchmarks + +This workflow is prepared mostly to analyse the output of benchmarks from +`test/Exploratory_Benchmarks`. See `test/Exploratory_Benchmarks/README.md` for +more information. diff --git a/tools/performance/benchmark-analysis/data/benchmarks-vectorized-3-2023-07-17.txt b/tools/performance/benchmark-analysis/data/benchmarks-vectorized-3-2023-07-17.txt new file mode 100644 index 00000000000..adff5f36efb --- /dev/null +++ b/tools/performance/benchmark-analysis/data/benchmarks-vectorized-3-2023-07-17.txt @@ -0,0 +1,5050 @@ +Primitive_Map_Test.current_implementation/iteration:0: 22.02ms +Primitive_Map_Test.current_implementation/iteration:1: 9.4ms +Primitive_Map_Test.current_implementation/iteration:2: 9.6ms +Primitive_Map_Test.current_implementation/iteration:3: 11.7ms +Primitive_Map_Test.current_implementation/iteration:4: 9.87ms +Primitive_Map_Test.current_implementation/iteration:5: 8.32ms +Primitive_Map_Test.current_implementation/iteration:6: 9.4ms +Primitive_Map_Test.current_implementation/iteration:7: 7.24ms +Primitive_Map_Test.current_implementation/iteration:8: 5.97ms +Primitive_Map_Test.current_implementation/iteration:9: 16.51ms +Primitive_Map_Test.current_implementation/iteration:10: 6.84ms +Primitive_Map_Test.current_implementation/iteration:11: 7.6ms +Primitive_Map_Test.current_implementation/iteration:12: 8.31ms +Primitive_Map_Test.current_implementation/iteration:13: 8.66ms +Primitive_Map_Test.current_implementation/iteration:14: 8.24ms +Primitive_Map_Test.current_implementation/iteration:15: 6.47ms +Primitive_Map_Test.current_implementation/iteration:16: 5.89ms +Primitive_Map_Test.current_implementation/iteration:17: 6.46ms +Primitive_Map_Test.current_implementation/iteration:18: 7.47ms +Primitive_Map_Test.current_implementation/iteration:19: 7.6ms +Primitive_Map_Test.current_implementation/iteration:20: 13.05ms +Primitive_Map_Test.current_implementation/iteration:21: 6.44ms +Primitive_Map_Test.current_implementation/iteration:22: 6.15ms +Primitive_Map_Test.current_implementation/iteration:23: 7.01ms +Primitive_Map_Test.current_implementation/iteration:24: 6.43ms +Primitive_Map_Test.current_implementation/iteration:25: 6.31ms +Primitive_Map_Test.current_implementation/iteration:26: 5.16ms +Primitive_Map_Test.current_implementation/iteration:27: 6.18ms +Primitive_Map_Test.current_implementation/iteration:28: 7.72ms +Primitive_Map_Test.current_implementation/iteration:29: 5.08ms +Primitive_Map_Test.current_implementation/iteration:30: 6.27ms +Primitive_Map_Test.current_implementation/iteration:31: 15.52ms +Primitive_Map_Test.current_implementation/iteration:32: 6.59ms +Primitive_Map_Test.current_implementation/iteration:33: 5.38ms +Primitive_Map_Test.current_implementation/iteration:34: 5.11ms +Primitive_Map_Test.current_implementation/iteration:35: 4.8ms +Primitive_Map_Test.current_implementation/iteration:36: 7.1ms +Primitive_Map_Test.current_implementation/iteration:37: 5.53ms +Primitive_Map_Test.current_implementation/iteration:38: 6.64ms +Primitive_Map_Test.current_implementation/iteration:39: 4.38ms +Primitive_Map_Test.current_implementation/iteration:40: 5.54ms +Primitive_Map_Test.current_implementation/iteration:41: 5.79ms +Primitive_Map_Test.current_implementation/iteration:42: 5.72ms +Primitive_Map_Test.current_implementation/iteration:43: 5.8ms +Primitive_Map_Test.current_implementation/iteration:44: 4.95ms +Primitive_Map_Test.current_implementation/iteration:45: 5.41ms +Primitive_Map_Test.current_implementation/iteration:46: 5.3ms +Primitive_Map_Test.current_implementation/iteration:47: 4.76ms +Primitive_Map_Test.current_implementation/iteration:48: 4.92ms +Primitive_Map_Test.current_implementation/iteration:49: 5.8ms +Primitive_Map_Test.current_implementation/iteration:50: 9.64ms +Primitive_Map_Test.current_implementation/iteration:51: 11.35ms +Primitive_Map_Test.current_implementation/iteration:52: 9.12ms +Primitive_Map_Test.current_implementation/iteration:53: 11.92ms +Primitive_Map_Test.current_implementation/iteration:54: 12.5ms +Primitive_Map_Test.current_implementation/iteration:55: 7.02ms +Primitive_Map_Test.current_implementation/iteration:56: 6.16ms +Primitive_Map_Test.current_implementation/iteration:57: 6.59ms +Primitive_Map_Test.current_implementation/iteration:58: 5.74ms +Primitive_Map_Test.current_implementation/iteration:59: 6.05ms +Primitive_Map_Test.current_implementation/iteration:60: 6.65ms +Primitive_Map_Test.current_implementation/iteration:61: 5.96ms +Primitive_Map_Test.current_implementation/iteration:62: 8.56ms +Primitive_Map_Test.current_implementation/iteration:63: 4.04ms +Primitive_Map_Test.current_implementation/iteration:64: 5.23ms +Primitive_Map_Test.current_implementation/iteration:65: 4ms +Primitive_Map_Test.current_implementation/iteration:66: 5.78ms +Primitive_Map_Test.current_implementation/iteration:67: 5.25ms +Primitive_Map_Test.current_implementation/iteration:68: 6.27ms +Primitive_Map_Test.current_implementation/iteration:69: 5.43ms +Primitive_Map_Test.current_implementation/iteration:70: 5.71ms +Primitive_Map_Test.current_implementation/iteration:71: 5.97ms +Primitive_Map_Test.current_implementation/iteration:72: 5.8ms +Primitive_Map_Test.current_implementation/iteration:73: 5.74ms +Primitive_Map_Test.current_implementation/iteration:74: 4.12ms +Primitive_Map_Test.current_implementation/iteration:75: 5.28ms +Primitive_Map_Test.current_implementation/iteration:76: 5.38ms +Primitive_Map_Test.current_implementation/iteration:77: 6ms +Primitive_Map_Test.current_implementation/iteration:78: 5.79ms +Primitive_Map_Test.current_implementation/iteration:79: 5.84ms +Primitive_Map_Test.current_implementation/iteration:80: 5.44ms +Primitive_Map_Test.current_implementation/iteration:81: 5.39ms +Primitive_Map_Test.current_implementation/iteration:82: 5.76ms +Primitive_Map_Test.current_implementation/iteration:83: 5.47ms +Primitive_Map_Test.current_implementation/iteration:84: 4.66ms +Primitive_Map_Test.current_implementation/iteration:85: 4.14ms +Primitive_Map_Test.current_implementation/iteration:86: 4.82ms +Primitive_Map_Test.current_implementation/iteration:87: 4.3ms +Primitive_Map_Test.current_implementation/iteration:88: 4.97ms +Primitive_Map_Test.current_implementation/iteration:89: 5.54ms +Primitive_Map_Test.current_implementation/iteration:90: 4.73ms +Primitive_Map_Test.current_implementation/iteration:91: 14.03ms +Primitive_Map_Test.current_implementation/iteration:92: 5.46ms +Primitive_Map_Test.current_implementation/iteration:93: 5.1ms +Primitive_Map_Test.current_implementation/iteration:94: 5.62ms +Primitive_Map_Test.current_implementation/iteration:95: 4.94ms +Primitive_Map_Test.current_implementation/iteration:96: 4.37ms +Primitive_Map_Test.current_implementation/iteration:97: 4.39ms +Primitive_Map_Test.current_implementation/iteration:98: 5.78ms +Primitive_Map_Test.current_implementation/iteration:99: 5.41ms +Primitive_Map_Test.current_implementation average: 6.84ms +Primitive_Map_Test.java_map/iteration:0: 9.23ms +Primitive_Map_Test.java_map/iteration:1: 2.87ms +Primitive_Map_Test.java_map/iteration:2: 2.19ms +Primitive_Map_Test.java_map/iteration:3: 2.08ms +Primitive_Map_Test.java_map/iteration:4: 2.01ms +Primitive_Map_Test.java_map/iteration:5: 2.06ms +Primitive_Map_Test.java_map/iteration:6: 2.03ms +Primitive_Map_Test.java_map/iteration:7: 2ms +Primitive_Map_Test.java_map/iteration:8: 2.05ms +Primitive_Map_Test.java_map/iteration:9: 2.51ms +Primitive_Map_Test.java_map/iteration:10: 2.41ms +Primitive_Map_Test.java_map/iteration:11: 1.91ms +Primitive_Map_Test.java_map/iteration:12: 1.95ms +Primitive_Map_Test.java_map/iteration:13: 1.83ms +Primitive_Map_Test.java_map/iteration:14: 2.22ms +Primitive_Map_Test.java_map/iteration:15: 1.95ms +Primitive_Map_Test.java_map/iteration:16: 2.47ms +Primitive_Map_Test.java_map/iteration:17: 2.15ms +Primitive_Map_Test.java_map/iteration:18: 1.51ms +Primitive_Map_Test.java_map/iteration:19: 1.5ms +Primitive_Map_Test.java_map/iteration:20: 1.43ms +Primitive_Map_Test.java_map/iteration:21: 1.88ms +Primitive_Map_Test.java_map/iteration:22: 1.89ms +Primitive_Map_Test.java_map/iteration:23: 2.41ms +Primitive_Map_Test.java_map/iteration:24: 2.05ms +Primitive_Map_Test.java_map/iteration:25: 2.23ms +Primitive_Map_Test.java_map/iteration:26: 2.23ms +Primitive_Map_Test.java_map/iteration:27: 2.86ms +Primitive_Map_Test.java_map/iteration:28: 2.21ms +Primitive_Map_Test.java_map/iteration:29: 1.95ms +Primitive_Map_Test.java_map/iteration:30: 1.91ms +Primitive_Map_Test.java_map/iteration:31: 1.93ms +Primitive_Map_Test.java_map/iteration:32: 1.92ms +Primitive_Map_Test.java_map/iteration:33: 2.41ms +Primitive_Map_Test.java_map/iteration:34: 2.44ms +Primitive_Map_Test.java_map/iteration:35: 2.2ms +Primitive_Map_Test.java_map/iteration:36: 1.97ms +Primitive_Map_Test.java_map/iteration:37: 1.92ms +Primitive_Map_Test.java_map/iteration:38: 1.89ms +Primitive_Map_Test.java_map/iteration:39: 1.7ms +Primitive_Map_Test.java_map/iteration:40: 1.65ms +Primitive_Map_Test.java_map/iteration:41: 1.43ms +Primitive_Map_Test.java_map/iteration:42: 1.6ms +Primitive_Map_Test.java_map/iteration:43: 1.38ms +Primitive_Map_Test.java_map/iteration:44: 1.3ms +Primitive_Map_Test.java_map/iteration:45: 1.26ms +Primitive_Map_Test.java_map/iteration:46: 1.27ms +Primitive_Map_Test.java_map/iteration:47: 1.27ms +Primitive_Map_Test.java_map/iteration:48: 1.28ms +Primitive_Map_Test.java_map/iteration:49: 1.95ms +Primitive_Map_Test.java_map/iteration:50: 1.83ms +Primitive_Map_Test.java_map/iteration:51: 9.56ms +Primitive_Map_Test.java_map/iteration:52: 1.42ms +Primitive_Map_Test.java_map/iteration:53: 1.33ms +Primitive_Map_Test.java_map/iteration:54: 1.94ms +Primitive_Map_Test.java_map/iteration:55: 1.45ms +Primitive_Map_Test.java_map/iteration:56: 1.78ms +Primitive_Map_Test.java_map/iteration:57: 1.67ms +Primitive_Map_Test.java_map/iteration:58: 1.67ms +Primitive_Map_Test.java_map/iteration:59: 1.29ms +Primitive_Map_Test.java_map/iteration:60: 1.54ms +Primitive_Map_Test.java_map/iteration:61: 1.25ms +Primitive_Map_Test.java_map/iteration:62: 2.2ms +Primitive_Map_Test.java_map/iteration:63: 1.34ms +Primitive_Map_Test.java_map/iteration:64: 1.85ms +Primitive_Map_Test.java_map/iteration:65: 1.44ms +Primitive_Map_Test.java_map/iteration:66: 1.26ms +Primitive_Map_Test.java_map/iteration:67: 1.22ms +Primitive_Map_Test.java_map/iteration:68: 1.39ms +Primitive_Map_Test.java_map/iteration:69: 1.44ms +Primitive_Map_Test.java_map/iteration:70: 1.21ms +Primitive_Map_Test.java_map/iteration:71: 1.84ms +Primitive_Map_Test.java_map/iteration:72: 1.57ms +Primitive_Map_Test.java_map/iteration:73: 1.47ms +Primitive_Map_Test.java_map/iteration:74: 1.51ms +Primitive_Map_Test.java_map/iteration:75: 1.35ms +Primitive_Map_Test.java_map/iteration:76: 1.33ms +Primitive_Map_Test.java_map/iteration:77: 1.58ms +Primitive_Map_Test.java_map/iteration:78: 1.37ms +Primitive_Map_Test.java_map/iteration:79: 1.29ms +Primitive_Map_Test.java_map/iteration:80: 1.51ms +Primitive_Map_Test.java_map/iteration:81: 1.63ms +Primitive_Map_Test.java_map/iteration:82: 1.27ms +Primitive_Map_Test.java_map/iteration:83: 1.68ms +Primitive_Map_Test.java_map/iteration:84: 1.34ms +Primitive_Map_Test.java_map/iteration:85: 1.33ms +Primitive_Map_Test.java_map/iteration:86: 1.71ms +Primitive_Map_Test.java_map/iteration:87: 1.29ms +Primitive_Map_Test.java_map/iteration:88: 1.22ms +Primitive_Map_Test.java_map/iteration:89: 1.67ms +Primitive_Map_Test.java_map/iteration:90: 1.66ms +Primitive_Map_Test.java_map/iteration:91: 1.5ms +Primitive_Map_Test.java_map/iteration:92: 1.56ms +Primitive_Map_Test.java_map/iteration:93: 1.24ms +Primitive_Map_Test.java_map/iteration:94: 1.22ms +Primitive_Map_Test.java_map/iteration:95: 1.76ms +Primitive_Map_Test.java_map/iteration:96: 1.55ms +Primitive_Map_Test.java_map/iteration:97: 1.34ms +Primitive_Map_Test.java_map/iteration:98: 1.62ms +Primitive_Map_Test.java_map/iteration:99: 1.61ms +Primitive_Map_Test.java_map average: 1.88ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:0: 218.84ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:1: 216.52ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:2: 226.1ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:3: 169.93ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:4: 136.98ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:5: 138.06ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:6: 149.02ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:7: 178.61ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:8: 136.43ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:9: 140.47ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:10: 171.06ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:11: 147.94ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:12: 135.07ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:13: 186.55ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:14: 170.47ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:15: 142.35ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:16: 186.97ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:17: 215.23ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:18: 201.7ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:19: 138.78ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:20: 179.79ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:21: 140.38ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:22: 170.16ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:23: 142.75ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:24: 155.24ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:25: 124.64ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:26: 105.19ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:27: 109.12ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:28: 143.3ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:29: 206.65ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:30: 116.03ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:31: 105.21ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:32: 160.01ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:33: 147.51ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:34: 154.97ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:35: 109.42ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:36: 106.06ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:37: 103.6ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:38: 106.01ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:39: 138.24ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:40: 102.21ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:41: 110.92ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:42: 110.93ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:43: 108.5ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:44: 161.96ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:45: 106.18ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:46: 107.55ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:47: 104.64ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:48: 114.98ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:49: 153.14ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:50: 108.17ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:51: 105.88ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:52: 106.98ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:53: 107ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:54: 142.4ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:55: 107.65ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:56: 105.79ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:57: 105.1ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:58: 200.59ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:59: 168.24ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:60: 165.05ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:61: 166.47ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:62: 167.49ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:63: 121.96ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:64: 108.21ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:65: 151.2ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:66: 105.95ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:67: 103.13ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:68: 103.61ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:69: 107.47ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:70: 111.04ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:71: 163.69ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:72: 114.49ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:73: 109.48ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:74: 106.68ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:75: 116.59ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:76: 109.25ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:77: 188.99ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:78: 146.17ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:79: 113.94ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:80: 112.76ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:81: 110.41ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:82: 151.15ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:83: 107.56ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:84: 107.39ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:85: 106.94ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:86: 105.77ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:87: 147.01ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:88: 229.75ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:89: 110.87ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:90: 121.81ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:91: 115.23ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:92: 109.29ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:93: 112.64ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:94: 176.07ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:95: 109.42ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:96: 107.84ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:97: 99.83ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:98: 105.23ms +Primitive_Map_Test.enso_map_as_vector+convert_dates/iteration:99: 107.4ms +Primitive_Map_Test.enso_map_as_vector+convert_dates average: 136.05ms +Primitive_Map_Test.enso_map_as_vector/iteration:0: 105.89ms +Primitive_Map_Test.enso_map_as_vector/iteration:1: 114.27ms +Primitive_Map_Test.enso_map_as_vector/iteration:2: 94.63ms +Primitive_Map_Test.enso_map_as_vector/iteration:3: 67.37ms +Primitive_Map_Test.enso_map_as_vector/iteration:4: 67.45ms +Primitive_Map_Test.enso_map_as_vector/iteration:5: 68.24ms +Primitive_Map_Test.enso_map_as_vector/iteration:6: 68.54ms +Primitive_Map_Test.enso_map_as_vector/iteration:7: 136.82ms +Primitive_Map_Test.enso_map_as_vector/iteration:8: 105.1ms +Primitive_Map_Test.enso_map_as_vector/iteration:9: 121.54ms +Primitive_Map_Test.enso_map_as_vector/iteration:10: 152.21ms +Primitive_Map_Test.enso_map_as_vector/iteration:11: 124.88ms +Primitive_Map_Test.enso_map_as_vector/iteration:12: 118.29ms +Primitive_Map_Test.enso_map_as_vector/iteration:13: 150.79ms +Primitive_Map_Test.enso_map_as_vector/iteration:14: 120.24ms +Primitive_Map_Test.enso_map_as_vector/iteration:15: 139.25ms +Primitive_Map_Test.enso_map_as_vector/iteration:16: 104.61ms +Primitive_Map_Test.enso_map_as_vector/iteration:17: 64.46ms +Primitive_Map_Test.enso_map_as_vector/iteration:18: 66.83ms +Primitive_Map_Test.enso_map_as_vector/iteration:19: 185.03ms +Primitive_Map_Test.enso_map_as_vector/iteration:20: 88.15ms +Primitive_Map_Test.enso_map_as_vector/iteration:21: 79.55ms +Primitive_Map_Test.enso_map_as_vector/iteration:22: 62.21ms +Primitive_Map_Test.enso_map_as_vector/iteration:23: 70.58ms +Primitive_Map_Test.enso_map_as_vector/iteration:24: 76.04ms +Primitive_Map_Test.enso_map_as_vector/iteration:25: 63.47ms +Primitive_Map_Test.enso_map_as_vector/iteration:26: 68.7ms +Primitive_Map_Test.enso_map_as_vector/iteration:27: 60.74ms +Primitive_Map_Test.enso_map_as_vector/iteration:28: 61.73ms +Primitive_Map_Test.enso_map_as_vector/iteration:29: 142.58ms +Primitive_Map_Test.enso_map_as_vector/iteration:30: 67.12ms +Primitive_Map_Test.enso_map_as_vector/iteration:31: 68.36ms +Primitive_Map_Test.enso_map_as_vector/iteration:32: 65.36ms +Primitive_Map_Test.enso_map_as_vector/iteration:33: 63.26ms +Primitive_Map_Test.enso_map_as_vector/iteration:34: 63.21ms +Primitive_Map_Test.enso_map_as_vector/iteration:35: 63.94ms +Primitive_Map_Test.enso_map_as_vector/iteration:36: 99.15ms +Primitive_Map_Test.enso_map_as_vector/iteration:37: 139.36ms +Primitive_Map_Test.enso_map_as_vector/iteration:38: 113.21ms +Primitive_Map_Test.enso_map_as_vector/iteration:39: 63.65ms +Primitive_Map_Test.enso_map_as_vector/iteration:40: 62.6ms +Primitive_Map_Test.enso_map_as_vector/iteration:41: 61.72ms +Primitive_Map_Test.enso_map_as_vector/iteration:42: 60.18ms +Primitive_Map_Test.enso_map_as_vector/iteration:43: 69.18ms +Primitive_Map_Test.enso_map_as_vector/iteration:44: 162.54ms +Primitive_Map_Test.enso_map_as_vector/iteration:45: 122.74ms +Primitive_Map_Test.enso_map_as_vector/iteration:46: 66.78ms +Primitive_Map_Test.enso_map_as_vector/iteration:47: 63.61ms +Primitive_Map_Test.enso_map_as_vector/iteration:48: 62.33ms +Primitive_Map_Test.enso_map_as_vector/iteration:49: 124.45ms +Primitive_Map_Test.enso_map_as_vector/iteration:50: 110.01ms +Primitive_Map_Test.enso_map_as_vector/iteration:51: 112.58ms +Primitive_Map_Test.enso_map_as_vector/iteration:52: 120.92ms +Primitive_Map_Test.enso_map_as_vector/iteration:53: 114.81ms +Primitive_Map_Test.enso_map_as_vector/iteration:54: 116.82ms +Primitive_Map_Test.enso_map_as_vector/iteration:55: 115.73ms +Primitive_Map_Test.enso_map_as_vector/iteration:56: 114.67ms +Primitive_Map_Test.enso_map_as_vector/iteration:57: 112.24ms +Primitive_Map_Test.enso_map_as_vector/iteration:58: 112.32ms +Primitive_Map_Test.enso_map_as_vector/iteration:59: 112.31ms +Primitive_Map_Test.enso_map_as_vector/iteration:60: 115.67ms +Primitive_Map_Test.enso_map_as_vector/iteration:61: 106.62ms +Primitive_Map_Test.enso_map_as_vector/iteration:62: 179.99ms +Primitive_Map_Test.enso_map_as_vector/iteration:63: 99.52ms +Primitive_Map_Test.enso_map_as_vector/iteration:64: 89.32ms +Primitive_Map_Test.enso_map_as_vector/iteration:65: 62.15ms +Primitive_Map_Test.enso_map_as_vector/iteration:66: 63.63ms +Primitive_Map_Test.enso_map_as_vector/iteration:67: 62.96ms +Primitive_Map_Test.enso_map_as_vector/iteration:68: 58.52ms +Primitive_Map_Test.enso_map_as_vector/iteration:69: 68.23ms +Primitive_Map_Test.enso_map_as_vector/iteration:70: 62.2ms +Primitive_Map_Test.enso_map_as_vector/iteration:71: 61.48ms +Primitive_Map_Test.enso_map_as_vector/iteration:72: 172.1ms +Primitive_Map_Test.enso_map_as_vector/iteration:73: 114.38ms +Primitive_Map_Test.enso_map_as_vector/iteration:74: 87.98ms +Primitive_Map_Test.enso_map_as_vector/iteration:75: 68.47ms +Primitive_Map_Test.enso_map_as_vector/iteration:76: 63.72ms +Primitive_Map_Test.enso_map_as_vector/iteration:77: 65.14ms +Primitive_Map_Test.enso_map_as_vector/iteration:78: 66.1ms +Primitive_Map_Test.enso_map_as_vector/iteration:79: 128.62ms +Primitive_Map_Test.enso_map_as_vector/iteration:80: 109.6ms +Primitive_Map_Test.enso_map_as_vector/iteration:81: 127.9ms +Primitive_Map_Test.enso_map_as_vector/iteration:82: 117.33ms +Primitive_Map_Test.enso_map_as_vector/iteration:83: 117.63ms +Primitive_Map_Test.enso_map_as_vector/iteration:84: 116.54ms +Primitive_Map_Test.enso_map_as_vector/iteration:85: 115.16ms +Primitive_Map_Test.enso_map_as_vector/iteration:86: 117.53ms +Primitive_Map_Test.enso_map_as_vector/iteration:87: 110.57ms +Primitive_Map_Test.enso_map_as_vector/iteration:88: 118.49ms +Primitive_Map_Test.enso_map_as_vector/iteration:89: 112.17ms +Primitive_Map_Test.enso_map_as_vector/iteration:90: 116.91ms +Primitive_Map_Test.enso_map_as_vector/iteration:91: 106.44ms +Primitive_Map_Test.enso_map_as_vector/iteration:92: 195.25ms +Primitive_Map_Test.enso_map_as_vector/iteration:93: 102.38ms +Primitive_Map_Test.enso_map_as_vector/iteration:94: 82.67ms +Primitive_Map_Test.enso_map_as_vector/iteration:95: 61.01ms +Primitive_Map_Test.enso_map_as_vector/iteration:96: 61.38ms +Primitive_Map_Test.enso_map_as_vector/iteration:97: 62.26ms +Primitive_Map_Test.enso_map_as_vector/iteration:98: 58.5ms +Primitive_Map_Test.enso_map_as_vector/iteration:99: 68.05ms +Primitive_Map_Test.enso_map_as_vector average: 96.3ms +Primitive_Map_Test.enso_map_with_builder/iteration:0: 447.23ms +Primitive_Map_Test.enso_map_with_builder/iteration:1: 451.55ms +Primitive_Map_Test.enso_map_with_builder/iteration:2: 289.69ms +Primitive_Map_Test.enso_map_with_builder/iteration:3: 229.11ms +Primitive_Map_Test.enso_map_with_builder/iteration:4: 219.43ms +Primitive_Map_Test.enso_map_with_builder/iteration:5: 67.63ms +Primitive_Map_Test.enso_map_with_builder/iteration:6: 67.28ms +Primitive_Map_Test.enso_map_with_builder/iteration:7: 65.6ms +Primitive_Map_Test.enso_map_with_builder/iteration:8: 62.2ms +Primitive_Map_Test.enso_map_with_builder/iteration:9: 62.76ms +Primitive_Map_Test.enso_map_with_builder/iteration:10: 59.28ms +Primitive_Map_Test.enso_map_with_builder/iteration:11: 61.12ms +Primitive_Map_Test.enso_map_with_builder/iteration:12: 66.41ms +Primitive_Map_Test.enso_map_with_builder/iteration:13: 60.39ms +Primitive_Map_Test.enso_map_with_builder/iteration:14: 61.65ms +Primitive_Map_Test.enso_map_with_builder/iteration:15: 60.83ms +Primitive_Map_Test.enso_map_with_builder/iteration:16: 66.25ms +Primitive_Map_Test.enso_map_with_builder/iteration:17: 64.22ms +Primitive_Map_Test.enso_map_with_builder/iteration:18: 68.97ms +Primitive_Map_Test.enso_map_with_builder/iteration:19: 60.27ms +Primitive_Map_Test.enso_map_with_builder/iteration:20: 63.13ms +Primitive_Map_Test.enso_map_with_builder/iteration:21: 61.52ms +Primitive_Map_Test.enso_map_with_builder/iteration:22: 58.42ms +Primitive_Map_Test.enso_map_with_builder/iteration:23: 60.03ms +Primitive_Map_Test.enso_map_with_builder/iteration:24: 58.69ms +Primitive_Map_Test.enso_map_with_builder/iteration:25: 62.2ms +Primitive_Map_Test.enso_map_with_builder/iteration:26: 64.9ms +Primitive_Map_Test.enso_map_with_builder/iteration:27: 57.92ms +Primitive_Map_Test.enso_map_with_builder/iteration:28: 59.28ms +Primitive_Map_Test.enso_map_with_builder/iteration:29: 62.61ms +Primitive_Map_Test.enso_map_with_builder/iteration:30: 89.73ms +Primitive_Map_Test.enso_map_with_builder/iteration:31: 85.28ms +Primitive_Map_Test.enso_map_with_builder/iteration:32: 65.73ms +Primitive_Map_Test.enso_map_with_builder/iteration:33: 60.27ms +Primitive_Map_Test.enso_map_with_builder/iteration:34: 62.24ms +Primitive_Map_Test.enso_map_with_builder/iteration:35: 62.7ms +Primitive_Map_Test.enso_map_with_builder/iteration:36: 61.57ms +Primitive_Map_Test.enso_map_with_builder/iteration:37: 58.91ms +Primitive_Map_Test.enso_map_with_builder/iteration:38: 62.62ms +Primitive_Map_Test.enso_map_with_builder/iteration:39: 59.19ms +Primitive_Map_Test.enso_map_with_builder/iteration:40: 58.2ms +Primitive_Map_Test.enso_map_with_builder/iteration:41: 60.51ms +Primitive_Map_Test.enso_map_with_builder/iteration:42: 59.47ms +Primitive_Map_Test.enso_map_with_builder/iteration:43: 68.54ms +Primitive_Map_Test.enso_map_with_builder/iteration:44: 61.27ms +Primitive_Map_Test.enso_map_with_builder/iteration:45: 62.91ms +Primitive_Map_Test.enso_map_with_builder/iteration:46: 62.23ms +Primitive_Map_Test.enso_map_with_builder/iteration:47: 63.22ms +Primitive_Map_Test.enso_map_with_builder/iteration:48: 63.3ms +Primitive_Map_Test.enso_map_with_builder/iteration:49: 59.77ms +Primitive_Map_Test.enso_map_with_builder/iteration:50: 59.68ms +Primitive_Map_Test.enso_map_with_builder/iteration:51: 58.39ms +Primitive_Map_Test.enso_map_with_builder/iteration:52: 62.15ms +Primitive_Map_Test.enso_map_with_builder/iteration:53: 58.74ms +Primitive_Map_Test.enso_map_with_builder/iteration:54: 59.36ms +Primitive_Map_Test.enso_map_with_builder/iteration:55: 59.12ms +Primitive_Map_Test.enso_map_with_builder/iteration:56: 58.79ms +Primitive_Map_Test.enso_map_with_builder/iteration:57: 61.4ms +Primitive_Map_Test.enso_map_with_builder/iteration:58: 65.2ms +Primitive_Map_Test.enso_map_with_builder/iteration:59: 66.03ms +Primitive_Map_Test.enso_map_with_builder/iteration:60: 60.4ms +Primitive_Map_Test.enso_map_with_builder/iteration:61: 58.89ms +Primitive_Map_Test.enso_map_with_builder/iteration:62: 59.33ms +Primitive_Map_Test.enso_map_with_builder/iteration:63: 61.85ms +Primitive_Map_Test.enso_map_with_builder/iteration:64: 59.84ms +Primitive_Map_Test.enso_map_with_builder/iteration:65: 68.06ms +Primitive_Map_Test.enso_map_with_builder/iteration:66: 60.19ms +Primitive_Map_Test.enso_map_with_builder/iteration:67: 62.73ms +Primitive_Map_Test.enso_map_with_builder/iteration:68: 59.14ms +Primitive_Map_Test.enso_map_with_builder/iteration:69: 57.11ms +Primitive_Map_Test.enso_map_with_builder/iteration:70: 63.79ms +Primitive_Map_Test.enso_map_with_builder/iteration:71: 105.01ms +Primitive_Map_Test.enso_map_with_builder/iteration:72: 84.98ms +Primitive_Map_Test.enso_map_with_builder/iteration:73: 64.58ms +Primitive_Map_Test.enso_map_with_builder/iteration:74: 61.19ms +Primitive_Map_Test.enso_map_with_builder/iteration:75: 66.21ms +Primitive_Map_Test.enso_map_with_builder/iteration:76: 60.18ms +Primitive_Map_Test.enso_map_with_builder/iteration:77: 62.18ms +Primitive_Map_Test.enso_map_with_builder/iteration:78: 61.83ms +Primitive_Map_Test.enso_map_with_builder/iteration:79: 60.73ms +Primitive_Map_Test.enso_map_with_builder/iteration:80: 62.23ms +Primitive_Map_Test.enso_map_with_builder/iteration:81: 63.28ms +Primitive_Map_Test.enso_map_with_builder/iteration:82: 59.22ms +Primitive_Map_Test.enso_map_with_builder/iteration:83: 58.56ms +Primitive_Map_Test.enso_map_with_builder/iteration:84: 58.22ms +Primitive_Map_Test.enso_map_with_builder/iteration:85: 58.04ms +Primitive_Map_Test.enso_map_with_builder/iteration:86: 63.48ms +Primitive_Map_Test.enso_map_with_builder/iteration:87: 59.65ms +Primitive_Map_Test.enso_map_with_builder/iteration:88: 63.48ms +Primitive_Map_Test.enso_map_with_builder/iteration:89: 63.7ms +Primitive_Map_Test.enso_map_with_builder/iteration:90: 59.56ms +Primitive_Map_Test.enso_map_with_builder/iteration:91: 61.21ms +Primitive_Map_Test.enso_map_with_builder/iteration:92: 59.12ms +Primitive_Map_Test.enso_map_with_builder/iteration:93: 59.09ms +Primitive_Map_Test.enso_map_with_builder/iteration:94: 61.85ms +Primitive_Map_Test.enso_map_with_builder/iteration:95: 59.34ms +Primitive_Map_Test.enso_map_with_builder/iteration:96: 60.25ms +Primitive_Map_Test.enso_map_with_builder/iteration:97: 60.13ms +Primitive_Map_Test.enso_map_with_builder/iteration:98: 62.94ms +Primitive_Map_Test.enso_map_with_builder/iteration:99: 59.33ms +Primitive_Map_Test.enso_map_with_builder average: 76.08ms +Boxed_Map_Test.current_implementation/iteration:0: 831ms +Boxed_Map_Test.current_implementation/iteration:1: 665.45ms +Boxed_Map_Test.current_implementation/iteration:2: 706.62ms +Boxed_Map_Test.current_implementation/iteration:3: 678.3ms +Boxed_Map_Test.current_implementation/iteration:4: 678.02ms +Boxed_Map_Test.current_implementation/iteration:5: 674.36ms +Boxed_Map_Test.current_implementation/iteration:6: 682.92ms +Boxed_Map_Test.current_implementation/iteration:7: 694.82ms +Boxed_Map_Test.current_implementation/iteration:8: 696.57ms +Boxed_Map_Test.current_implementation/iteration:9: 665.32ms +Boxed_Map_Test.current_implementation/iteration:10: 738.48ms +Boxed_Map_Test.current_implementation/iteration:11: 695.93ms +Boxed_Map_Test.current_implementation/iteration:12: 744.16ms +Boxed_Map_Test.current_implementation/iteration:13: 687.96ms +Boxed_Map_Test.current_implementation/iteration:14: 735.76ms +Boxed_Map_Test.current_implementation/iteration:15: 706.81ms +Boxed_Map_Test.current_implementation/iteration:16: 646.19ms +Boxed_Map_Test.current_implementation/iteration:17: 658.42ms +Boxed_Map_Test.current_implementation/iteration:18: 661.67ms +Boxed_Map_Test.current_implementation/iteration:19: 658.51ms +Boxed_Map_Test.current_implementation/iteration:20: 638.69ms +Boxed_Map_Test.current_implementation/iteration:21: 657.09ms +Boxed_Map_Test.current_implementation/iteration:22: 668.86ms +Boxed_Map_Test.current_implementation/iteration:23: 678.39ms +Boxed_Map_Test.current_implementation/iteration:24: 666.03ms +Boxed_Map_Test.current_implementation/iteration:25: 659.41ms +Boxed_Map_Test.current_implementation/iteration:26: 647.18ms +Boxed_Map_Test.current_implementation/iteration:27: 662.14ms +Boxed_Map_Test.current_implementation/iteration:28: 656.76ms +Boxed_Map_Test.current_implementation/iteration:29: 659.41ms +Boxed_Map_Test.current_implementation/iteration:30: 649.8ms +Boxed_Map_Test.current_implementation/iteration:31: 649.9ms +Boxed_Map_Test.current_implementation/iteration:32: 666.12ms +Boxed_Map_Test.current_implementation/iteration:33: 657.35ms +Boxed_Map_Test.current_implementation/iteration:34: 653.84ms +Boxed_Map_Test.current_implementation/iteration:35: 659.5ms +Boxed_Map_Test.current_implementation/iteration:36: 683.93ms +Boxed_Map_Test.current_implementation/iteration:37: 640.58ms +Boxed_Map_Test.current_implementation/iteration:38: 641.98ms +Boxed_Map_Test.current_implementation/iteration:39: 657.11ms +Boxed_Map_Test.current_implementation/iteration:40: 651.98ms +Boxed_Map_Test.current_implementation/iteration:41: 649.26ms +Boxed_Map_Test.current_implementation/iteration:42: 646.34ms +Boxed_Map_Test.current_implementation/iteration:43: 647.12ms +Boxed_Map_Test.current_implementation/iteration:44: 664.67ms +Boxed_Map_Test.current_implementation/iteration:45: 703.59ms +Boxed_Map_Test.current_implementation/iteration:46: 671.46ms +Boxed_Map_Test.current_implementation/iteration:47: 629.74ms +Boxed_Map_Test.current_implementation/iteration:48: 643.11ms +Boxed_Map_Test.current_implementation/iteration:49: 637.83ms +Boxed_Map_Test.current_implementation/iteration:50: 647.76ms +Boxed_Map_Test.current_implementation/iteration:51: 632.22ms +Boxed_Map_Test.current_implementation/iteration:52: 630.25ms +Boxed_Map_Test.current_implementation/iteration:53: 661.21ms +Boxed_Map_Test.current_implementation/iteration:54: 654.45ms +Boxed_Map_Test.current_implementation/iteration:55: 753.74ms +Boxed_Map_Test.current_implementation/iteration:56: 738.68ms +Boxed_Map_Test.current_implementation/iteration:57: 658.47ms +Boxed_Map_Test.current_implementation/iteration:58: 658.67ms +Boxed_Map_Test.current_implementation/iteration:59: 651.09ms +Boxed_Map_Test.current_implementation/iteration:60: 645.77ms +Boxed_Map_Test.current_implementation/iteration:61: 627.32ms +Boxed_Map_Test.current_implementation/iteration:62: 643.97ms +Boxed_Map_Test.current_implementation/iteration:63: 648.12ms +Boxed_Map_Test.current_implementation/iteration:64: 706.13ms +Boxed_Map_Test.current_implementation/iteration:65: 637.35ms +Boxed_Map_Test.current_implementation/iteration:66: 634.37ms +Boxed_Map_Test.current_implementation/iteration:67: 642.14ms +Boxed_Map_Test.current_implementation/iteration:68: 653.21ms +Boxed_Map_Test.current_implementation/iteration:69: 664.32ms +Boxed_Map_Test.current_implementation/iteration:70: 676.36ms +Boxed_Map_Test.current_implementation/iteration:71: 681.17ms +Boxed_Map_Test.current_implementation/iteration:72: 663.89ms +Boxed_Map_Test.current_implementation/iteration:73: 673.98ms +Boxed_Map_Test.current_implementation/iteration:74: 658.61ms +Boxed_Map_Test.current_implementation/iteration:75: 642.42ms +Boxed_Map_Test.current_implementation/iteration:76: 640.64ms +Boxed_Map_Test.current_implementation/iteration:77: 654.97ms +Boxed_Map_Test.current_implementation/iteration:78: 669.07ms +Boxed_Map_Test.current_implementation/iteration:79: 652.44ms +Boxed_Map_Test.current_implementation/iteration:80: 639.12ms +Boxed_Map_Test.current_implementation/iteration:81: 653.83ms +Boxed_Map_Test.current_implementation/iteration:82: 651.12ms +Boxed_Map_Test.current_implementation/iteration:83: 640.71ms +Boxed_Map_Test.current_implementation/iteration:84: 661.93ms +Boxed_Map_Test.current_implementation/iteration:85: 665.04ms +Boxed_Map_Test.current_implementation/iteration:86: 636.66ms +Boxed_Map_Test.current_implementation/iteration:87: 621.35ms +Boxed_Map_Test.current_implementation/iteration:88: 629.49ms +Boxed_Map_Test.current_implementation/iteration:89: 646.8ms +Boxed_Map_Test.current_implementation/iteration:90: 639.66ms +Boxed_Map_Test.current_implementation/iteration:91: 624.56ms +Boxed_Map_Test.current_implementation/iteration:92: 640.86ms +Boxed_Map_Test.current_implementation/iteration:93: 649.63ms +Boxed_Map_Test.current_implementation/iteration:94: 635.44ms +Boxed_Map_Test.current_implementation/iteration:95: 634.07ms +Boxed_Map_Test.current_implementation/iteration:96: 628.39ms +Boxed_Map_Test.current_implementation/iteration:97: 633.12ms +Boxed_Map_Test.current_implementation/iteration:98: 641.55ms +Boxed_Map_Test.current_implementation/iteration:99: 656.67ms +Boxed_Map_Test.current_implementation average: 662.39ms +Boxed_Map_Test.java_map/iteration:0: 654.21ms +Boxed_Map_Test.java_map/iteration:1: 644.85ms +Boxed_Map_Test.java_map/iteration:2: 651.13ms +Boxed_Map_Test.java_map/iteration:3: 655.44ms +Boxed_Map_Test.java_map/iteration:4: 650.01ms +Boxed_Map_Test.java_map/iteration:5: 646.82ms +Boxed_Map_Test.java_map/iteration:6: 638.54ms +Boxed_Map_Test.java_map/iteration:7: 643.04ms +Boxed_Map_Test.java_map/iteration:8: 643.84ms +Boxed_Map_Test.java_map/iteration:9: 644.74ms +Boxed_Map_Test.java_map/iteration:10: 647.12ms +Boxed_Map_Test.java_map/iteration:11: 646.74ms +Boxed_Map_Test.java_map/iteration:12: 650.01ms +Boxed_Map_Test.java_map/iteration:13: 646.57ms +Boxed_Map_Test.java_map/iteration:14: 625.17ms +Boxed_Map_Test.java_map/iteration:15: 647.29ms +Boxed_Map_Test.java_map/iteration:16: 659.26ms +Boxed_Map_Test.java_map/iteration:17: 637.9ms +Boxed_Map_Test.java_map/iteration:18: 657.9ms +Boxed_Map_Test.java_map/iteration:19: 704.84ms +Boxed_Map_Test.java_map/iteration:20: 659.03ms +Boxed_Map_Test.java_map/iteration:21: 654.84ms +Boxed_Map_Test.java_map/iteration:22: 637.59ms +Boxed_Map_Test.java_map/iteration:23: 660.06ms +Boxed_Map_Test.java_map/iteration:24: 720.4ms +Boxed_Map_Test.java_map/iteration:25: 655.58ms +Boxed_Map_Test.java_map/iteration:26: 648.06ms +Boxed_Map_Test.java_map/iteration:27: 657.79ms +Boxed_Map_Test.java_map/iteration:28: 638.73ms +Boxed_Map_Test.java_map/iteration:29: 639.43ms +Boxed_Map_Test.java_map/iteration:30: 634.55ms +Boxed_Map_Test.java_map/iteration:31: 651.89ms +Boxed_Map_Test.java_map/iteration:32: 635.92ms +Boxed_Map_Test.java_map/iteration:33: 656.23ms +Boxed_Map_Test.java_map/iteration:34: 647.4ms +Boxed_Map_Test.java_map/iteration:35: 652.51ms +Boxed_Map_Test.java_map/iteration:36: 648.71ms +Boxed_Map_Test.java_map/iteration:37: 643.96ms +Boxed_Map_Test.java_map/iteration:38: 647.49ms +Boxed_Map_Test.java_map/iteration:39: 646.06ms +Boxed_Map_Test.java_map/iteration:40: 669.69ms +Boxed_Map_Test.java_map/iteration:41: 641.14ms +Boxed_Map_Test.java_map/iteration:42: 648.93ms +Boxed_Map_Test.java_map/iteration:43: 659.53ms +Boxed_Map_Test.java_map/iteration:44: 641.24ms +Boxed_Map_Test.java_map/iteration:45: 636.11ms +Boxed_Map_Test.java_map/iteration:46: 630.13ms +Boxed_Map_Test.java_map/iteration:47: 683.3ms +Boxed_Map_Test.java_map/iteration:48: 647.33ms +Boxed_Map_Test.java_map/iteration:49: 632.2ms +Boxed_Map_Test.java_map/iteration:50: 653.14ms +Boxed_Map_Test.java_map/iteration:51: 655.19ms +Boxed_Map_Test.java_map/iteration:52: 650.27ms +Boxed_Map_Test.java_map/iteration:53: 650.78ms +Boxed_Map_Test.java_map/iteration:54: 626.51ms +Boxed_Map_Test.java_map/iteration:55: 646.28ms +Boxed_Map_Test.java_map/iteration:56: 635.55ms +Boxed_Map_Test.java_map/iteration:57: 607.31ms +Boxed_Map_Test.java_map/iteration:58: 627.97ms +Boxed_Map_Test.java_map/iteration:59: 648.11ms +Boxed_Map_Test.java_map/iteration:60: 648.6ms +Boxed_Map_Test.java_map/iteration:61: 646.52ms +Boxed_Map_Test.java_map/iteration:62: 643.04ms +Boxed_Map_Test.java_map/iteration:63: 654.84ms +Boxed_Map_Test.java_map/iteration:64: 645.92ms +Boxed_Map_Test.java_map/iteration:65: 636.14ms +Boxed_Map_Test.java_map/iteration:66: 634.22ms +Boxed_Map_Test.java_map/iteration:67: 629.7ms +Boxed_Map_Test.java_map/iteration:68: 635.1ms +Boxed_Map_Test.java_map/iteration:69: 658.42ms +Boxed_Map_Test.java_map/iteration:70: 639.77ms +Boxed_Map_Test.java_map/iteration:71: 657.5ms +Boxed_Map_Test.java_map/iteration:72: 627.82ms +Boxed_Map_Test.java_map/iteration:73: 637.08ms +Boxed_Map_Test.java_map/iteration:74: 654.78ms +Boxed_Map_Test.java_map/iteration:75: 643.04ms +Boxed_Map_Test.java_map/iteration:76: 629.31ms +Boxed_Map_Test.java_map/iteration:77: 636.6ms +Boxed_Map_Test.java_map/iteration:78: 636.22ms +Boxed_Map_Test.java_map/iteration:79: 650.24ms +Boxed_Map_Test.java_map/iteration:80: 664.45ms +Boxed_Map_Test.java_map/iteration:81: 631.38ms +Boxed_Map_Test.java_map/iteration:82: 644.41ms +Boxed_Map_Test.java_map/iteration:83: 643.79ms +Boxed_Map_Test.java_map/iteration:84: 640.05ms +Boxed_Map_Test.java_map/iteration:85: 642.13ms +Boxed_Map_Test.java_map/iteration:86: 624.48ms +Boxed_Map_Test.java_map/iteration:87: 632.84ms +Boxed_Map_Test.java_map/iteration:88: 657.87ms +Boxed_Map_Test.java_map/iteration:89: 637.25ms +Boxed_Map_Test.java_map/iteration:90: 628.11ms +Boxed_Map_Test.java_map/iteration:91: 637.66ms +Boxed_Map_Test.java_map/iteration:92: 636.37ms +Boxed_Map_Test.java_map/iteration:93: 659.67ms +Boxed_Map_Test.java_map/iteration:94: 639.27ms +Boxed_Map_Test.java_map/iteration:95: 631.73ms +Boxed_Map_Test.java_map/iteration:96: 646.2ms +Boxed_Map_Test.java_map/iteration:97: 646.65ms +Boxed_Map_Test.java_map/iteration:98: 638.91ms +Boxed_Map_Test.java_map/iteration:99: 647.19ms +Boxed_Map_Test.java_map average: 645.98ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:0: 843.19ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:1: 824.79ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:2: 815.3ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:3: 827.86ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:4: 824.81ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:5: 817.24ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:6: 806.52ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:7: 818.4ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:8: 813.57ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:9: 796.97ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:10: 819.92ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:11: 811.9ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:12: 808.85ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:13: 808.81ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:14: 816.87ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:15: 809ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:16: 816.24ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:17: 804.71ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:18: 801.68ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:19: 823.99ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:20: 826.09ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:21: 828.63ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:22: 825.27ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:23: 779.05ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:24: 748.3ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:25: 860.71ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:26: 785.35ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:27: 758.6ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:28: 766.91ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:29: 788.5ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:30: 768.16ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:31: 790.36ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:32: 760.75ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:33: 748.45ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:34: 789.55ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:35: 759.4ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:36: 754.83ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:37: 783.95ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:38: 768.4ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:39: 759.9ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:40: 784.12ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:41: 744.2ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:42: 751.9ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:43: 760.75ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:44: 785.44ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:45: 758.95ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:46: 762.47ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:47: 765.73ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:48: 777.8ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:49: 782.14ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:50: 763.62ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:51: 767.99ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:52: 780.88ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:53: 776.55ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:54: 761.42ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:55: 759.02ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:56: 760.27ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:57: 788.89ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:58: 781.01ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:59: 768.64ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:60: 775.63ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:61: 781.05ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:62: 771.42ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:63: 757ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:64: 768.51ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:65: 760.16ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:66: 795.51ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:67: 768.34ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:68: 775.18ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:69: 775.54ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:70: 787.83ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:71: 791.55ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:72: 763.16ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:73: 784.07ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:74: 776.47ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:75: 777.89ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:76: 772.8ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:77: 762.64ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:78: 791.11ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:79: 802.6ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:80: 782.15ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:81: 779.51ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:82: 777.14ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:83: 792.64ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:84: 776.3ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:85: 787ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:86: 791.14ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:87: 773.19ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:88: 788.88ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:89: 786.19ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:90: 772.86ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:91: 781.34ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:92: 777.29ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:93: 777.39ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:94: 769.39ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:95: 788.87ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:96: 782.95ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:97: 789.75ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:98: 771.25ms +Boxed_Map_Test.enso_map_as_vector+convert_dates/iteration:99: 778.52ms +Boxed_Map_Test.enso_map_as_vector+convert_dates average: 785.06ms +Boxed_Map_Test.enso_map_as_vector/iteration:0: 785.47ms +Boxed_Map_Test.enso_map_as_vector/iteration:1: 758.97ms +Boxed_Map_Test.enso_map_as_vector/iteration:2: 729.7ms +Boxed_Map_Test.enso_map_as_vector/iteration:3: 713.62ms +Boxed_Map_Test.enso_map_as_vector/iteration:4: 736.29ms +Boxed_Map_Test.enso_map_as_vector/iteration:5: 724.95ms +Boxed_Map_Test.enso_map_as_vector/iteration:6: 746.74ms +Boxed_Map_Test.enso_map_as_vector/iteration:7: 719.53ms +Boxed_Map_Test.enso_map_as_vector/iteration:8: 730.44ms +Boxed_Map_Test.enso_map_as_vector/iteration:9: 728.45ms +Boxed_Map_Test.enso_map_as_vector/iteration:10: 717.7ms +Boxed_Map_Test.enso_map_as_vector/iteration:11: 707.04ms +Boxed_Map_Test.enso_map_as_vector/iteration:12: 744.74ms +Boxed_Map_Test.enso_map_as_vector/iteration:13: 730.13ms +Boxed_Map_Test.enso_map_as_vector/iteration:14: 694.67ms +Boxed_Map_Test.enso_map_as_vector/iteration:15: 722.57ms +Boxed_Map_Test.enso_map_as_vector/iteration:16: 715.35ms +Boxed_Map_Test.enso_map_as_vector/iteration:17: 721.55ms +Boxed_Map_Test.enso_map_as_vector/iteration:18: 713.95ms +Boxed_Map_Test.enso_map_as_vector/iteration:19: 722.13ms +Boxed_Map_Test.enso_map_as_vector/iteration:20: 724.33ms +Boxed_Map_Test.enso_map_as_vector/iteration:21: 729.79ms +Boxed_Map_Test.enso_map_as_vector/iteration:22: 712.77ms +Boxed_Map_Test.enso_map_as_vector/iteration:23: 725.68ms +Boxed_Map_Test.enso_map_as_vector/iteration:24: 726.5ms +Boxed_Map_Test.enso_map_as_vector/iteration:25: 706.03ms +Boxed_Map_Test.enso_map_as_vector/iteration:26: 737.42ms +Boxed_Map_Test.enso_map_as_vector/iteration:27: 721.04ms +Boxed_Map_Test.enso_map_as_vector/iteration:28: 722.12ms +Boxed_Map_Test.enso_map_as_vector/iteration:29: 719.34ms +Boxed_Map_Test.enso_map_as_vector/iteration:30: 737.39ms +Boxed_Map_Test.enso_map_as_vector/iteration:31: 723.79ms +Boxed_Map_Test.enso_map_as_vector/iteration:32: 727.3ms +Boxed_Map_Test.enso_map_as_vector/iteration:33: 734.31ms +Boxed_Map_Test.enso_map_as_vector/iteration:34: 730.49ms +Boxed_Map_Test.enso_map_as_vector/iteration:35: 729.42ms +Boxed_Map_Test.enso_map_as_vector/iteration:36: 723.29ms +Boxed_Map_Test.enso_map_as_vector/iteration:37: 729.99ms +Boxed_Map_Test.enso_map_as_vector/iteration:38: 733.03ms +Boxed_Map_Test.enso_map_as_vector/iteration:39: 719.91ms +Boxed_Map_Test.enso_map_as_vector/iteration:40: 741.31ms +Boxed_Map_Test.enso_map_as_vector/iteration:41: 729.78ms +Boxed_Map_Test.enso_map_as_vector/iteration:42: 721.61ms +Boxed_Map_Test.enso_map_as_vector/iteration:43: 723.9ms +Boxed_Map_Test.enso_map_as_vector/iteration:44: 730.88ms +Boxed_Map_Test.enso_map_as_vector/iteration:45: 735.99ms +Boxed_Map_Test.enso_map_as_vector/iteration:46: 723.94ms +Boxed_Map_Test.enso_map_as_vector/iteration:47: 731.08ms +Boxed_Map_Test.enso_map_as_vector/iteration:48: 742.07ms +Boxed_Map_Test.enso_map_as_vector/iteration:49: 725.23ms +Boxed_Map_Test.enso_map_as_vector/iteration:50: 720.11ms +Boxed_Map_Test.enso_map_as_vector/iteration:51: 731.38ms +Boxed_Map_Test.enso_map_as_vector/iteration:52: 712.47ms +Boxed_Map_Test.enso_map_as_vector/iteration:53: 717.22ms +Boxed_Map_Test.enso_map_as_vector/iteration:54: 709.04ms +Boxed_Map_Test.enso_map_as_vector/iteration:55: 738.92ms +Boxed_Map_Test.enso_map_as_vector/iteration:56: 730.39ms +Boxed_Map_Test.enso_map_as_vector/iteration:57: 744.39ms +Boxed_Map_Test.enso_map_as_vector/iteration:58: 733.17ms +Boxed_Map_Test.enso_map_as_vector/iteration:59: 731.09ms +Boxed_Map_Test.enso_map_as_vector/iteration:60: 731.29ms +Boxed_Map_Test.enso_map_as_vector/iteration:61: 713.18ms +Boxed_Map_Test.enso_map_as_vector/iteration:62: 730.25ms +Boxed_Map_Test.enso_map_as_vector/iteration:63: 731.94ms +Boxed_Map_Test.enso_map_as_vector/iteration:64: 726.8ms +Boxed_Map_Test.enso_map_as_vector/iteration:65: 725.08ms +Boxed_Map_Test.enso_map_as_vector/iteration:66: 748.5ms +Boxed_Map_Test.enso_map_as_vector/iteration:67: 731.62ms +Boxed_Map_Test.enso_map_as_vector/iteration:68: 731.54ms +Boxed_Map_Test.enso_map_as_vector/iteration:69: 742.59ms +Boxed_Map_Test.enso_map_as_vector/iteration:70: 741.65ms +Boxed_Map_Test.enso_map_as_vector/iteration:71: 734.46ms +Boxed_Map_Test.enso_map_as_vector/iteration:72: 736.66ms +Boxed_Map_Test.enso_map_as_vector/iteration:73: 740.6ms +Boxed_Map_Test.enso_map_as_vector/iteration:74: 750.98ms +Boxed_Map_Test.enso_map_as_vector/iteration:75: 719.09ms +Boxed_Map_Test.enso_map_as_vector/iteration:76: 732.51ms +Boxed_Map_Test.enso_map_as_vector/iteration:77: 745.85ms +Boxed_Map_Test.enso_map_as_vector/iteration:78: 722.7ms +Boxed_Map_Test.enso_map_as_vector/iteration:79: 747.59ms +Boxed_Map_Test.enso_map_as_vector/iteration:80: 717.4ms +Boxed_Map_Test.enso_map_as_vector/iteration:81: 730.95ms +Boxed_Map_Test.enso_map_as_vector/iteration:82: 727.69ms +Boxed_Map_Test.enso_map_as_vector/iteration:83: 714.09ms +Boxed_Map_Test.enso_map_as_vector/iteration:84: 729.31ms +Boxed_Map_Test.enso_map_as_vector/iteration:85: 737.33ms +Boxed_Map_Test.enso_map_as_vector/iteration:86: 744.45ms +Boxed_Map_Test.enso_map_as_vector/iteration:87: 737.05ms +Boxed_Map_Test.enso_map_as_vector/iteration:88: 737.52ms +Boxed_Map_Test.enso_map_as_vector/iteration:89: 743.06ms +Boxed_Map_Test.enso_map_as_vector/iteration:90: 739.97ms +Boxed_Map_Test.enso_map_as_vector/iteration:91: 731.47ms +Boxed_Map_Test.enso_map_as_vector/iteration:92: 739.33ms +Boxed_Map_Test.enso_map_as_vector/iteration:93: 746.37ms +Boxed_Map_Test.enso_map_as_vector/iteration:94: 738.07ms +Boxed_Map_Test.enso_map_as_vector/iteration:95: 743.62ms +Boxed_Map_Test.enso_map_as_vector/iteration:96: 735.19ms +Boxed_Map_Test.enso_map_as_vector/iteration:97: 730.29ms +Boxed_Map_Test.enso_map_as_vector/iteration:98: 736.58ms +Boxed_Map_Test.enso_map_as_vector/iteration:99: 724.41ms +Boxed_Map_Test.enso_map_as_vector average: 730.21ms +Boxed_Map_Test.enso_map_with_builder/iteration:0: 1000.52ms +Boxed_Map_Test.enso_map_with_builder/iteration:1: 767.93ms +Boxed_Map_Test.enso_map_with_builder/iteration:2: 985.94ms +Boxed_Map_Test.enso_map_with_builder/iteration:3: 718.32ms +Boxed_Map_Test.enso_map_with_builder/iteration:4: 729ms +Boxed_Map_Test.enso_map_with_builder/iteration:5: 713.03ms +Boxed_Map_Test.enso_map_with_builder/iteration:6: 733ms +Boxed_Map_Test.enso_map_with_builder/iteration:7: 717.12ms +Boxed_Map_Test.enso_map_with_builder/iteration:8: 699.08ms +Boxed_Map_Test.enso_map_with_builder/iteration:9: 732.69ms +Boxed_Map_Test.enso_map_with_builder/iteration:10: 729ms +Boxed_Map_Test.enso_map_with_builder/iteration:11: 706.53ms +Boxed_Map_Test.enso_map_with_builder/iteration:12: 726.75ms +Boxed_Map_Test.enso_map_with_builder/iteration:13: 730.44ms +Boxed_Map_Test.enso_map_with_builder/iteration:14: 726.06ms +Boxed_Map_Test.enso_map_with_builder/iteration:15: 708.37ms +Boxed_Map_Test.enso_map_with_builder/iteration:16: 713.19ms +Boxed_Map_Test.enso_map_with_builder/iteration:17: 717.84ms +Boxed_Map_Test.enso_map_with_builder/iteration:18: 710.9ms +Boxed_Map_Test.enso_map_with_builder/iteration:19: 708.88ms +Boxed_Map_Test.enso_map_with_builder/iteration:20: 746.12ms +Boxed_Map_Test.enso_map_with_builder/iteration:21: 706.45ms +Boxed_Map_Test.enso_map_with_builder/iteration:22: 712.29ms +Boxed_Map_Test.enso_map_with_builder/iteration:23: 727.52ms +Boxed_Map_Test.enso_map_with_builder/iteration:24: 733.39ms +Boxed_Map_Test.enso_map_with_builder/iteration:25: 713.83ms +Boxed_Map_Test.enso_map_with_builder/iteration:26: 707.63ms +Boxed_Map_Test.enso_map_with_builder/iteration:27: 716.6ms +Boxed_Map_Test.enso_map_with_builder/iteration:28: 713.86ms +Boxed_Map_Test.enso_map_with_builder/iteration:29: 719.92ms +Boxed_Map_Test.enso_map_with_builder/iteration:30: 721.67ms +Boxed_Map_Test.enso_map_with_builder/iteration:31: 731.68ms +Boxed_Map_Test.enso_map_with_builder/iteration:32: 744.23ms +Boxed_Map_Test.enso_map_with_builder/iteration:33: 714.66ms +Boxed_Map_Test.enso_map_with_builder/iteration:34: 752.26ms +Boxed_Map_Test.enso_map_with_builder/iteration:35: 729.48ms +Boxed_Map_Test.enso_map_with_builder/iteration:36: 728.36ms +Boxed_Map_Test.enso_map_with_builder/iteration:37: 718.33ms +Boxed_Map_Test.enso_map_with_builder/iteration:38: 725.38ms +Boxed_Map_Test.enso_map_with_builder/iteration:39: 726.71ms +Boxed_Map_Test.enso_map_with_builder/iteration:40: 727.15ms +Boxed_Map_Test.enso_map_with_builder/iteration:41: 723.4ms +Boxed_Map_Test.enso_map_with_builder/iteration:42: 723.02ms +Boxed_Map_Test.enso_map_with_builder/iteration:43: 722ms +Boxed_Map_Test.enso_map_with_builder/iteration:44: 725.92ms +Boxed_Map_Test.enso_map_with_builder/iteration:45: 734.2ms +Boxed_Map_Test.enso_map_with_builder/iteration:46: 719.42ms +Boxed_Map_Test.enso_map_with_builder/iteration:47: 711.85ms +Boxed_Map_Test.enso_map_with_builder/iteration:48: 737.03ms +Boxed_Map_Test.enso_map_with_builder/iteration:49: 721.42ms +Boxed_Map_Test.enso_map_with_builder/iteration:50: 743.47ms +Boxed_Map_Test.enso_map_with_builder/iteration:51: 743.2ms +Boxed_Map_Test.enso_map_with_builder/iteration:52: 728.16ms +Boxed_Map_Test.enso_map_with_builder/iteration:53: 732.09ms +Boxed_Map_Test.enso_map_with_builder/iteration:54: 725.21ms +Boxed_Map_Test.enso_map_with_builder/iteration:55: 730.28ms +Boxed_Map_Test.enso_map_with_builder/iteration:56: 730.21ms +Boxed_Map_Test.enso_map_with_builder/iteration:57: 734.55ms +Boxed_Map_Test.enso_map_with_builder/iteration:58: 729.87ms +Boxed_Map_Test.enso_map_with_builder/iteration:59: 731.5ms +Boxed_Map_Test.enso_map_with_builder/iteration:60: 739.48ms +Boxed_Map_Test.enso_map_with_builder/iteration:61: 736.5ms +Boxed_Map_Test.enso_map_with_builder/iteration:62: 740.41ms +Boxed_Map_Test.enso_map_with_builder/iteration:63: 739.6ms +Boxed_Map_Test.enso_map_with_builder/iteration:64: 732.53ms +Boxed_Map_Test.enso_map_with_builder/iteration:65: 729.05ms +Boxed_Map_Test.enso_map_with_builder/iteration:66: 716.43ms +Boxed_Map_Test.enso_map_with_builder/iteration:67: 737.48ms +Boxed_Map_Test.enso_map_with_builder/iteration:68: 735.53ms +Boxed_Map_Test.enso_map_with_builder/iteration:69: 724.45ms +Boxed_Map_Test.enso_map_with_builder/iteration:70: 741.11ms +Boxed_Map_Test.enso_map_with_builder/iteration:71: 729.16ms +Boxed_Map_Test.enso_map_with_builder/iteration:72: 736.07ms +Boxed_Map_Test.enso_map_with_builder/iteration:73: 729.27ms +Boxed_Map_Test.enso_map_with_builder/iteration:74: 712.97ms +Boxed_Map_Test.enso_map_with_builder/iteration:75: 717.67ms +Boxed_Map_Test.enso_map_with_builder/iteration:76: 726.78ms +Boxed_Map_Test.enso_map_with_builder/iteration:77: 707.87ms +Boxed_Map_Test.enso_map_with_builder/iteration:78: 726.06ms +Boxed_Map_Test.enso_map_with_builder/iteration:79: 724.41ms +Boxed_Map_Test.enso_map_with_builder/iteration:80: 729.28ms +Boxed_Map_Test.enso_map_with_builder/iteration:81: 731.99ms +Boxed_Map_Test.enso_map_with_builder/iteration:82: 729.62ms +Boxed_Map_Test.enso_map_with_builder/iteration:83: 720.16ms +Boxed_Map_Test.enso_map_with_builder/iteration:84: 721.53ms +Boxed_Map_Test.enso_map_with_builder/iteration:85: 718.9ms +Boxed_Map_Test.enso_map_with_builder/iteration:86: 720.91ms +Boxed_Map_Test.enso_map_with_builder/iteration:87: 707.78ms +Boxed_Map_Test.enso_map_with_builder/iteration:88: 699.8ms +Boxed_Map_Test.enso_map_with_builder/iteration:89: 727.99ms +Boxed_Map_Test.enso_map_with_builder/iteration:90: 733.32ms +Boxed_Map_Test.enso_map_with_builder/iteration:91: 712.26ms +Boxed_Map_Test.enso_map_with_builder/iteration:92: 729.57ms +Boxed_Map_Test.enso_map_with_builder/iteration:93: 734.15ms +Boxed_Map_Test.enso_map_with_builder/iteration:94: 735.55ms +Boxed_Map_Test.enso_map_with_builder/iteration:95: 728.77ms +Boxed_Map_Test.enso_map_with_builder/iteration:96: 727.85ms +Boxed_Map_Test.enso_map_with_builder/iteration:97: 713.97ms +Boxed_Map_Test.enso_map_with_builder/iteration:98: 727.45ms +Boxed_Map_Test.enso_map_with_builder/iteration:99: 732.46ms +Boxed_Map_Test.enso_map_with_builder average: 731.05ms +Boxed_Map_Test_2.current_implementation/iteration:0: 43.59ms +Boxed_Map_Test_2.current_implementation/iteration:1: 22.54ms +Boxed_Map_Test_2.current_implementation/iteration:2: 8.37ms +Boxed_Map_Test_2.current_implementation/iteration:3: 9.19ms +Boxed_Map_Test_2.current_implementation/iteration:4: 7.91ms +Boxed_Map_Test_2.current_implementation/iteration:5: 8.72ms +Boxed_Map_Test_2.current_implementation/iteration:6: 7.82ms +Boxed_Map_Test_2.current_implementation/iteration:7: 8.13ms +Boxed_Map_Test_2.current_implementation/iteration:8: 7.58ms +Boxed_Map_Test_2.current_implementation/iteration:9: 8.08ms +Boxed_Map_Test_2.current_implementation/iteration:10: 8.01ms +Boxed_Map_Test_2.current_implementation/iteration:11: 19.72ms +Boxed_Map_Test_2.current_implementation/iteration:12: 6.19ms +Boxed_Map_Test_2.current_implementation/iteration:13: 6.92ms +Boxed_Map_Test_2.current_implementation/iteration:14: 6.45ms +Boxed_Map_Test_2.current_implementation/iteration:15: 7.6ms +Boxed_Map_Test_2.current_implementation/iteration:16: 6.22ms +Boxed_Map_Test_2.current_implementation/iteration:17: 6.89ms +Boxed_Map_Test_2.current_implementation/iteration:18: 5.69ms +Boxed_Map_Test_2.current_implementation/iteration:19: 5.7ms +Boxed_Map_Test_2.current_implementation/iteration:20: 6.05ms +Boxed_Map_Test_2.current_implementation/iteration:21: 5.64ms +Boxed_Map_Test_2.current_implementation/iteration:22: 6.27ms +Boxed_Map_Test_2.current_implementation/iteration:23: 5.53ms +Boxed_Map_Test_2.current_implementation/iteration:24: 12.29ms +Boxed_Map_Test_2.current_implementation/iteration:25: 5.19ms +Boxed_Map_Test_2.current_implementation/iteration:26: 7.72ms +Boxed_Map_Test_2.current_implementation/iteration:27: 6.63ms +Boxed_Map_Test_2.current_implementation/iteration:28: 7.17ms +Boxed_Map_Test_2.current_implementation/iteration:29: 17.92ms +Boxed_Map_Test_2.current_implementation/iteration:30: 6.04ms +Boxed_Map_Test_2.current_implementation/iteration:31: 7.09ms +Boxed_Map_Test_2.current_implementation/iteration:32: 6.47ms +Boxed_Map_Test_2.current_implementation/iteration:33: 6.26ms +Boxed_Map_Test_2.current_implementation/iteration:34: 7.35ms +Boxed_Map_Test_2.current_implementation/iteration:35: 6.09ms +Boxed_Map_Test_2.current_implementation/iteration:36: 8.1ms +Boxed_Map_Test_2.current_implementation/iteration:37: 6.31ms +Boxed_Map_Test_2.current_implementation/iteration:38: 7.03ms +Boxed_Map_Test_2.current_implementation/iteration:39: 6.21ms +Boxed_Map_Test_2.current_implementation/iteration:40: 8.12ms +Boxed_Map_Test_2.current_implementation/iteration:41: 7.05ms +Boxed_Map_Test_2.current_implementation/iteration:42: 7.2ms +Boxed_Map_Test_2.current_implementation/iteration:43: 7.03ms +Boxed_Map_Test_2.current_implementation/iteration:44: 7.43ms +Boxed_Map_Test_2.current_implementation/iteration:45: 7.44ms +Boxed_Map_Test_2.current_implementation/iteration:46: 16.56ms +Boxed_Map_Test_2.current_implementation/iteration:47: 7.28ms +Boxed_Map_Test_2.current_implementation/iteration:48: 7.74ms +Boxed_Map_Test_2.current_implementation/iteration:49: 6.38ms +Boxed_Map_Test_2.current_implementation/iteration:50: 6.2ms +Boxed_Map_Test_2.current_implementation/iteration:51: 5.8ms +Boxed_Map_Test_2.current_implementation/iteration:52: 5.48ms +Boxed_Map_Test_2.current_implementation/iteration:53: 5.89ms +Boxed_Map_Test_2.current_implementation/iteration:54: 6.99ms +Boxed_Map_Test_2.current_implementation/iteration:55: 6.99ms +Boxed_Map_Test_2.current_implementation/iteration:56: 6.81ms +Boxed_Map_Test_2.current_implementation/iteration:57: 5.69ms +Boxed_Map_Test_2.current_implementation/iteration:58: 6.76ms +Boxed_Map_Test_2.current_implementation/iteration:59: 6ms +Boxed_Map_Test_2.current_implementation/iteration:60: 5.88ms +Boxed_Map_Test_2.current_implementation/iteration:61: 6.99ms +Boxed_Map_Test_2.current_implementation/iteration:62: 5.55ms +Boxed_Map_Test_2.current_implementation/iteration:63: 13.38ms +Boxed_Map_Test_2.current_implementation/iteration:64: 5.49ms +Boxed_Map_Test_2.current_implementation/iteration:65: 5.94ms +Boxed_Map_Test_2.current_implementation/iteration:66: 5.91ms +Boxed_Map_Test_2.current_implementation/iteration:67: 6.84ms +Boxed_Map_Test_2.current_implementation/iteration:68: 7.7ms +Boxed_Map_Test_2.current_implementation/iteration:69: 5.87ms +Boxed_Map_Test_2.current_implementation/iteration:70: 7.27ms +Boxed_Map_Test_2.current_implementation/iteration:71: 6.17ms +Boxed_Map_Test_2.current_implementation/iteration:72: 7.1ms +Boxed_Map_Test_2.current_implementation/iteration:73: 5.77ms +Boxed_Map_Test_2.current_implementation/iteration:74: 6.4ms +Boxed_Map_Test_2.current_implementation/iteration:75: 6.43ms +Boxed_Map_Test_2.current_implementation/iteration:76: 6.19ms +Boxed_Map_Test_2.current_implementation/iteration:77: 7.45ms +Boxed_Map_Test_2.current_implementation/iteration:78: 6.43ms +Boxed_Map_Test_2.current_implementation/iteration:79: 14.36ms +Boxed_Map_Test_2.current_implementation/iteration:80: 5.21ms +Boxed_Map_Test_2.current_implementation/iteration:81: 6.81ms +Boxed_Map_Test_2.current_implementation/iteration:82: 5.57ms +Boxed_Map_Test_2.current_implementation/iteration:83: 6.15ms +Boxed_Map_Test_2.current_implementation/iteration:84: 5.17ms +Boxed_Map_Test_2.current_implementation/iteration:85: 5.06ms +Boxed_Map_Test_2.current_implementation/iteration:86: 5.56ms +Boxed_Map_Test_2.current_implementation/iteration:87: 5.59ms +Boxed_Map_Test_2.current_implementation/iteration:88: 4.8ms +Boxed_Map_Test_2.current_implementation/iteration:89: 4.71ms +Boxed_Map_Test_2.current_implementation/iteration:90: 5.01ms +Boxed_Map_Test_2.current_implementation/iteration:91: 4.43ms +Boxed_Map_Test_2.current_implementation/iteration:92: 4.31ms +Boxed_Map_Test_2.current_implementation/iteration:93: 4.6ms +Boxed_Map_Test_2.current_implementation/iteration:94: 4.44ms +Boxed_Map_Test_2.current_implementation/iteration:95: 4.29ms +Boxed_Map_Test_2.current_implementation/iteration:96: 4.67ms +Boxed_Map_Test_2.current_implementation/iteration:97: 12.8ms +Boxed_Map_Test_2.current_implementation/iteration:98: 4.59ms +Boxed_Map_Test_2.current_implementation/iteration:99: 4.64ms +Boxed_Map_Test_2.current_implementation average: 7.55ms +Boxed_Map_Test_2.java_map/iteration:0: 13.03ms +Boxed_Map_Test_2.java_map/iteration:1: 8.8ms +Boxed_Map_Test_2.java_map/iteration:2: 3.93ms +Boxed_Map_Test_2.java_map/iteration:3: 4.42ms +Boxed_Map_Test_2.java_map/iteration:4: 3.53ms +Boxed_Map_Test_2.java_map/iteration:5: 3.53ms +Boxed_Map_Test_2.java_map/iteration:6: 4.37ms +Boxed_Map_Test_2.java_map/iteration:7: 3.93ms +Boxed_Map_Test_2.java_map/iteration:8: 3.36ms +Boxed_Map_Test_2.java_map/iteration:9: 3.39ms +Boxed_Map_Test_2.java_map/iteration:10: 3.21ms +Boxed_Map_Test_2.java_map/iteration:11: 3.71ms +Boxed_Map_Test_2.java_map/iteration:12: 3.41ms +Boxed_Map_Test_2.java_map/iteration:13: 3.73ms +Boxed_Map_Test_2.java_map/iteration:14: 3.28ms +Boxed_Map_Test_2.java_map/iteration:15: 12.43ms +Boxed_Map_Test_2.java_map/iteration:16: 4.04ms +Boxed_Map_Test_2.java_map/iteration:17: 5.09ms +Boxed_Map_Test_2.java_map/iteration:18: 4.63ms +Boxed_Map_Test_2.java_map/iteration:19: 4.32ms +Boxed_Map_Test_2.java_map/iteration:20: 4.13ms +Boxed_Map_Test_2.java_map/iteration:21: 4.46ms +Boxed_Map_Test_2.java_map/iteration:22: 4.05ms +Boxed_Map_Test_2.java_map/iteration:23: 3.89ms +Boxed_Map_Test_2.java_map/iteration:24: 4.33ms +Boxed_Map_Test_2.java_map/iteration:25: 4.86ms +Boxed_Map_Test_2.java_map/iteration:26: 4.05ms +Boxed_Map_Test_2.java_map/iteration:27: 4.18ms +Boxed_Map_Test_2.java_map/iteration:28: 4.81ms +Boxed_Map_Test_2.java_map/iteration:29: 5.26ms +Boxed_Map_Test_2.java_map/iteration:30: 4.09ms +Boxed_Map_Test_2.java_map/iteration:31: 4.19ms +Boxed_Map_Test_2.java_map/iteration:32: 4.98ms +Boxed_Map_Test_2.java_map/iteration:33: 12.12ms +Boxed_Map_Test_2.java_map/iteration:34: 3.81ms +Boxed_Map_Test_2.java_map/iteration:35: 3.41ms +Boxed_Map_Test_2.java_map/iteration:36: 3.36ms +Boxed_Map_Test_2.java_map/iteration:37: 3.67ms +Boxed_Map_Test_2.java_map/iteration:38: 3.89ms +Boxed_Map_Test_2.java_map/iteration:39: 3.3ms +Boxed_Map_Test_2.java_map/iteration:40: 3.33ms +Boxed_Map_Test_2.java_map/iteration:41: 3.4ms +Boxed_Map_Test_2.java_map/iteration:42: 3.98ms +Boxed_Map_Test_2.java_map/iteration:43: 4.03ms +Boxed_Map_Test_2.java_map/iteration:44: 3.75ms +Boxed_Map_Test_2.java_map/iteration:45: 4.31ms +Boxed_Map_Test_2.java_map/iteration:46: 4.43ms +Boxed_Map_Test_2.java_map/iteration:47: 4.32ms +Boxed_Map_Test_2.java_map/iteration:48: 3.89ms +Boxed_Map_Test_2.java_map/iteration:49: 4.84ms +Boxed_Map_Test_2.java_map/iteration:50: 14.48ms +Boxed_Map_Test_2.java_map/iteration:51: 4.65ms +Boxed_Map_Test_2.java_map/iteration:52: 4.06ms +Boxed_Map_Test_2.java_map/iteration:53: 4.01ms +Boxed_Map_Test_2.java_map/iteration:54: 4.76ms +Boxed_Map_Test_2.java_map/iteration:55: 4.21ms +Boxed_Map_Test_2.java_map/iteration:56: 3.76ms +Boxed_Map_Test_2.java_map/iteration:57: 4.9ms +Boxed_Map_Test_2.java_map/iteration:58: 3.82ms +Boxed_Map_Test_2.java_map/iteration:59: 3.22ms +Boxed_Map_Test_2.java_map/iteration:60: 3.16ms +Boxed_Map_Test_2.java_map/iteration:61: 3.28ms +Boxed_Map_Test_2.java_map/iteration:62: 3.9ms +Boxed_Map_Test_2.java_map/iteration:63: 3.62ms +Boxed_Map_Test_2.java_map/iteration:64: 3.46ms +Boxed_Map_Test_2.java_map/iteration:65: 3.83ms +Boxed_Map_Test_2.java_map/iteration:66: 3.87ms +Boxed_Map_Test_2.java_map/iteration:67: 3.75ms +Boxed_Map_Test_2.java_map/iteration:68: 3.82ms +Boxed_Map_Test_2.java_map/iteration:69: 3.57ms +Boxed_Map_Test_2.java_map/iteration:70: 14.65ms +Boxed_Map_Test_2.java_map/iteration:71: 3.86ms +Boxed_Map_Test_2.java_map/iteration:72: 3.97ms +Boxed_Map_Test_2.java_map/iteration:73: 4.75ms +Boxed_Map_Test_2.java_map/iteration:74: 3.63ms +Boxed_Map_Test_2.java_map/iteration:75: 3.76ms +Boxed_Map_Test_2.java_map/iteration:76: 4.31ms +Boxed_Map_Test_2.java_map/iteration:77: 3.47ms +Boxed_Map_Test_2.java_map/iteration:78: 3.69ms +Boxed_Map_Test_2.java_map/iteration:79: 3.9ms +Boxed_Map_Test_2.java_map/iteration:80: 4.35ms +Boxed_Map_Test_2.java_map/iteration:81: 3.53ms +Boxed_Map_Test_2.java_map/iteration:82: 3.47ms +Boxed_Map_Test_2.java_map/iteration:83: 3.86ms +Boxed_Map_Test_2.java_map/iteration:84: 4.74ms +Boxed_Map_Test_2.java_map/iteration:85: 3.51ms +Boxed_Map_Test_2.java_map/iteration:86: 3.49ms +Boxed_Map_Test_2.java_map/iteration:87: 4.54ms +Boxed_Map_Test_2.java_map/iteration:88: 3.86ms +Boxed_Map_Test_2.java_map/iteration:89: 15.42ms +Boxed_Map_Test_2.java_map/iteration:90: 3.69ms +Boxed_Map_Test_2.java_map/iteration:91: 3.41ms +Boxed_Map_Test_2.java_map/iteration:92: 4.23ms +Boxed_Map_Test_2.java_map/iteration:93: 3.62ms +Boxed_Map_Test_2.java_map/iteration:94: 3.15ms +Boxed_Map_Test_2.java_map/iteration:95: 3.16ms +Boxed_Map_Test_2.java_map/iteration:96: 4.27ms +Boxed_Map_Test_2.java_map/iteration:97: 3.76ms +Boxed_Map_Test_2.java_map/iteration:98: 3.16ms +Boxed_Map_Test_2.java_map/iteration:99: 3.14ms +Boxed_Map_Test_2.java_map average: 4.56ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:0: 302.54ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:1: 248.33ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:2: 237.45ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:3: 246.54ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:4: 276.59ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:5: 187.28ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:6: 164.75ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:7: 177.85ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:8: 170.96ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:9: 218.72ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:10: 170.83ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:11: 169.3ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:12: 212.13ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:13: 211.63ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:14: 249.51ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:15: 188.35ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:16: 164.27ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:17: 240.44ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:18: 165.65ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:19: 165.67ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:20: 162.81ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:21: 213.73ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:22: 175.97ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:23: 170.8ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:24: 168.62ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:25: 223.39ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:26: 138.37ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:27: 148.34ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:28: 140.96ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:29: 178.41ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:30: 136.57ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:31: 134.14ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:32: 138.7ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:33: 175.24ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:34: 138.38ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:35: 141.75ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:36: 188.71ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:37: 136.46ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:38: 130.57ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:39: 172.53ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:40: 134.84ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:41: 168.59ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:42: 151.93ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:43: 138.67ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:44: 175.34ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:45: 134.46ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:46: 211.02ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:47: 153.52ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:48: 183.17ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:49: 139.01ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:50: 167.88ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:51: 154.6ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:52: 163.33ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:53: 140.98ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:54: 168.66ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:55: 149.4ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:56: 166.38ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:57: 167.03ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:58: 208.49ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:59: 162.58ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:60: 154.6ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:61: 160.11ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:62: 170.81ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:63: 141.06ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:64: 147.13ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:65: 156.2ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:66: 178.58ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:67: 200.4ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:68: 167.49ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:69: 137.44ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:70: 163.34ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:71: 160.55ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:72: 149.32ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:73: 167.1ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:74: 168.5ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:75: 148.18ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:76: 177.19ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:77: 169.03ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:78: 155.85ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:79: 154.56ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:80: 152.6ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:81: 150.21ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:82: 161.72ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:83: 151ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:84: 163ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:85: 175.99ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:86: 156.97ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:87: 149.5ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:88: 154.98ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:89: 137.73ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:90: 175.59ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:91: 174.34ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:92: 152.43ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:93: 157.91ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:94: 156.37ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:95: 149.21ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:96: 154.82ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:97: 157.33ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:98: 196.65ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates/iteration:99: 160.57ms +Boxed_Map_Test_2.enso_map_as_vector+convert_dates average: 170.4ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:0: 96.39ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:1: 77.95ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:2: 92.59ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:3: 91.77ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:4: 116.86ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:5: 115.38ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:6: 86.43ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:7: 104.33ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:8: 99.24ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:9: 135.11ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:10: 131.54ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:11: 99.6ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:12: 107.51ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:13: 110.6ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:14: 95.27ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:15: 101.75ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:16: 121.6ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:17: 139.23ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:18: 92.91ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:19: 81.87ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:20: 98.87ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:21: 87.24ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:22: 98.46ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:23: 110.3ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:24: 145.27ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:25: 112.06ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:26: 105.95ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:27: 104.57ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:28: 86.26ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:29: 103.17ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:30: 88.65ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:31: 106.14ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:32: 128.05ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:33: 116.73ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:34: 94.04ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:35: 80.44ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:36: 95.13ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:37: 104.43ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:38: 104.21ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:39: 145.23ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:40: 98.5ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:41: 81.72ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:42: 96.42ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:43: 103.45ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:44: 81.03ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:45: 133.01ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:46: 101.6ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:47: 98.39ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:48: 103.43ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:49: 98.26ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:50: 94.21ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:51: 105.46ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:52: 102.71ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:53: 187.23ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:54: 105.44ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:55: 91.21ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:56: 123.47ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:57: 95.78ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:58: 104.84ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:59: 121.34ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:60: 151.46ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:61: 102.27ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:62: 114.61ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:63: 94.54ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:64: 93.61ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:65: 143.15ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:66: 128.02ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:67: 112.33ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:68: 96.44ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:69: 92.06ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:70: 87.27ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:71: 90.52ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:72: 81.44ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:73: 80.9ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:74: 83.03ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:75: 82.26ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:76: 150.97ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:77: 78.66ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:78: 77.37ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:79: 78.96ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:80: 79.47ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:81: 80.85ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:82: 115.12ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:83: 142.24ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:84: 133.23ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:85: 107.48ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:86: 77.45ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:87: 165.15ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:88: 79.91ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:89: 77.22ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:90: 80.47ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:91: 78.3ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:92: 79.2ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:93: 76.27ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:94: 78.84ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:95: 79.46ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:96: 76.51ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:97: 79.85ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:98: 159.94ms +Boxed_Map_Test_2.enso_map_as_vector/iteration:99: 74.12ms +Boxed_Map_Test_2.enso_map_as_vector average: 102.82ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:0: 489.24ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:1: 281.47ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:2: 183.96ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:3: 181.03ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:4: 167.24ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:5: 154.96ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:6: 49.24ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:7: 50.02ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:8: 49.95ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:9: 49.25ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:10: 51.32ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:11: 50.67ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:12: 49.15ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:13: 49.66ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:14: 49.51ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:15: 50.21ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:16: 102.89ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:17: 52.87ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:18: 49.12ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:19: 49.53ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:20: 49.06ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:21: 53.27ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:22: 49.75ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:23: 50.05ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:24: 50.56ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:25: 49.35ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:26: 50.43ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:27: 48.25ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:28: 48.96ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:29: 51.68ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:30: 51.55ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:31: 50.54ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:32: 51.51ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:33: 50.2ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:34: 50.33ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:35: 49.13ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:36: 49.17ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:37: 48.87ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:38: 50.46ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:39: 56.76ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:40: 55.46ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:41: 48.63ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:42: 56.43ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:43: 50.62ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:44: 53.09ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:45: 48.24ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:46: 78.42ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:47: 62.53ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:48: 56.04ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:49: 56.01ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:50: 52.47ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:51: 50.64ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:52: 52.25ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:53: 48.15ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:54: 54.68ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:55: 57.63ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:56: 52.12ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:57: 55.28ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:58: 58.69ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:59: 54.46ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:60: 54.69ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:61: 51.72ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:62: 51.02ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:63: 50.73ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:64: 51.73ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:65: 50.19ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:66: 49.78ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:67: 68.21ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:68: 62.51ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:69: 49.78ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:70: 51.26ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:71: 49.53ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:72: 48.4ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:73: 48.08ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:74: 49.93ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:75: 49.82ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:76: 53.04ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:77: 48.15ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:78: 48.77ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:79: 58.7ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:80: 84.17ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:81: 55.35ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:82: 49.1ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:83: 53.43ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:84: 49.3ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:85: 48.71ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:86: 76.72ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:87: 83.33ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:88: 91.58ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:89: 95.98ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:90: 58.16ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:91: 52.18ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:92: 61.17ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:93: 62.78ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:94: 62.86ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:95: 60.26ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:96: 51.17ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:97: 52.1ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:98: 51.91ms +Boxed_Map_Test_2.enso_map_with_builder_append_long/iteration:99: 51.69ms +Boxed_Map_Test_2.enso_map_with_builder_append_long average: 66.21ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:0: 331.35ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:1: 262.65ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:2: 182.96ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:3: 197.61ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:4: 164.77ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:5: 49.83ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:6: 48.22ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:7: 47.33ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:8: 47.26ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:9: 46.82ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:10: 45.42ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:11: 46.03ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:12: 46.98ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:13: 48.43ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:14: 50.79ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:15: 51.49ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:16: 55.68ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:17: 71.83ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:18: 81.47ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:19: 60.61ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:20: 48.83ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:21: 49.7ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:22: 49.47ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:23: 50.02ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:24: 47.16ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:25: 46.81ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:26: 46.78ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:27: 48.29ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:28: 46.17ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:29: 48.11ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:30: 46.75ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:31: 47.84ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:32: 50.42ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:33: 49.36ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:34: 52.98ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:35: 61.53ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:36: 69.99ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:37: 45.19ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:38: 45.87ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:39: 47.01ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:40: 48.69ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:41: 48.26ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:42: 52.02ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:43: 46.66ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:44: 46.53ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:45: 48.62ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:46: 47.76ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:47: 45.91ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:48: 48.98ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:49: 48.44ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:50: 46.76ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:51: 45.79ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:52: 51.72ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:53: 63.78ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:54: 78.15ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:55: 63.58ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:56: 47.32ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:57: 51.86ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:58: 48.84ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:59: 47.48ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:60: 50.47ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:61: 50.49ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:62: 50.58ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:63: 46.57ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:64: 46.47ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:65: 47.88ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:66: 47.51ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:67: 46.22ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:68: 51.41ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:69: 54.23ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:70: 52.43ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:71: 59.34ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:72: 57.1ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:73: 50.74ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:74: 58.62ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:75: 62.88ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:76: 54.33ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:77: 46.54ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:78: 51.11ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:79: 46.7ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:80: 50.55ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:81: 48.98ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:82: 49.18ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:83: 48.46ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:84: 47.38ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:85: 49.45ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:86: 47.55ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:87: 54.57ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:88: 73.57ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:89: 67.7ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:90: 64.5ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:91: 56.59ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:92: 51.83ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:93: 48.42ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:94: 48.93ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:95: 50.28ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:96: 49.37ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:97: 48.33ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:98: 52.76ms +Boxed_Map_Test_2.enso_map_with_builder_append_object/iteration:99: 50.87ms +Boxed_Map_Test_2.enso_map_with_builder_append_object average: 60.54ms +Primitive_Bi_Map_Test.current_implementation/iteration:0: 32.49ms +Primitive_Bi_Map_Test.current_implementation/iteration:1: 4.78ms +Primitive_Bi_Map_Test.current_implementation/iteration:2: 5.37ms +Primitive_Bi_Map_Test.current_implementation/iteration:3: 6.83ms +Primitive_Bi_Map_Test.current_implementation/iteration:4: 6.79ms +Primitive_Bi_Map_Test.current_implementation/iteration:5: 7.62ms +Primitive_Bi_Map_Test.current_implementation/iteration:6: 6.7ms +Primitive_Bi_Map_Test.current_implementation/iteration:7: 7.2ms +Primitive_Bi_Map_Test.current_implementation/iteration:8: 5.1ms +Primitive_Bi_Map_Test.current_implementation/iteration:9: 5.15ms +Primitive_Bi_Map_Test.current_implementation/iteration:10: 7.47ms +Primitive_Bi_Map_Test.current_implementation/iteration:11: 6.26ms +Primitive_Bi_Map_Test.current_implementation/iteration:12: 9.35ms +Primitive_Bi_Map_Test.current_implementation/iteration:13: 7.66ms +Primitive_Bi_Map_Test.current_implementation/iteration:14: 7.43ms +Primitive_Bi_Map_Test.current_implementation/iteration:15: 7.41ms +Primitive_Bi_Map_Test.current_implementation/iteration:16: 5.02ms +Primitive_Bi_Map_Test.current_implementation/iteration:17: 4.71ms +Primitive_Bi_Map_Test.current_implementation/iteration:18: 7.58ms +Primitive_Bi_Map_Test.current_implementation/iteration:19: 7.18ms +Primitive_Bi_Map_Test.current_implementation/iteration:20: 7.44ms +Primitive_Bi_Map_Test.current_implementation/iteration:21: 7ms +Primitive_Bi_Map_Test.current_implementation/iteration:22: 7.07ms +Primitive_Bi_Map_Test.current_implementation/iteration:23: 7.48ms +Primitive_Bi_Map_Test.current_implementation/iteration:24: 7.25ms +Primitive_Bi_Map_Test.current_implementation/iteration:25: 7.33ms +Primitive_Bi_Map_Test.current_implementation/iteration:26: 7.02ms +Primitive_Bi_Map_Test.current_implementation/iteration:27: 7.71ms +Primitive_Bi_Map_Test.current_implementation/iteration:28: 8.63ms +Primitive_Bi_Map_Test.current_implementation/iteration:29: 6.66ms +Primitive_Bi_Map_Test.current_implementation/iteration:30: 5.7ms +Primitive_Bi_Map_Test.current_implementation/iteration:31: 5.12ms +Primitive_Bi_Map_Test.current_implementation/iteration:32: 7.55ms +Primitive_Bi_Map_Test.current_implementation/iteration:33: 7.39ms +Primitive_Bi_Map_Test.current_implementation/iteration:34: 7.83ms +Primitive_Bi_Map_Test.current_implementation/iteration:35: 7.51ms +Primitive_Bi_Map_Test.current_implementation/iteration:36: 7.29ms +Primitive_Bi_Map_Test.current_implementation/iteration:37: 7.16ms +Primitive_Bi_Map_Test.current_implementation/iteration:38: 6.9ms +Primitive_Bi_Map_Test.current_implementation/iteration:39: 7.73ms +Primitive_Bi_Map_Test.current_implementation/iteration:40: 4.72ms +Primitive_Bi_Map_Test.current_implementation/iteration:41: 7.48ms +Primitive_Bi_Map_Test.current_implementation/iteration:42: 8.34ms +Primitive_Bi_Map_Test.current_implementation/iteration:43: 7.67ms +Primitive_Bi_Map_Test.current_implementation/iteration:44: 7.9ms +Primitive_Bi_Map_Test.current_implementation/iteration:45: 6.45ms +Primitive_Bi_Map_Test.current_implementation/iteration:46: 8.3ms +Primitive_Bi_Map_Test.current_implementation/iteration:47: 8.74ms +Primitive_Bi_Map_Test.current_implementation/iteration:48: 6.65ms +Primitive_Bi_Map_Test.current_implementation/iteration:49: 8.16ms +Primitive_Bi_Map_Test.current_implementation/iteration:50: 8.15ms +Primitive_Bi_Map_Test.current_implementation/iteration:51: 7.06ms +Primitive_Bi_Map_Test.current_implementation/iteration:52: 5.35ms +Primitive_Bi_Map_Test.current_implementation/iteration:53: 6.76ms +Primitive_Bi_Map_Test.current_implementation/iteration:54: 6.64ms +Primitive_Bi_Map_Test.current_implementation/iteration:55: 4.46ms +Primitive_Bi_Map_Test.current_implementation/iteration:56: 5.49ms +Primitive_Bi_Map_Test.current_implementation/iteration:57: 5.62ms +Primitive_Bi_Map_Test.current_implementation/iteration:58: 5.71ms +Primitive_Bi_Map_Test.current_implementation/iteration:59: 5.47ms +Primitive_Bi_Map_Test.current_implementation/iteration:60: 6.77ms +Primitive_Bi_Map_Test.current_implementation/iteration:61: 6.11ms +Primitive_Bi_Map_Test.current_implementation/iteration:62: 6.65ms +Primitive_Bi_Map_Test.current_implementation/iteration:63: 5.21ms +Primitive_Bi_Map_Test.current_implementation/iteration:64: 6.58ms +Primitive_Bi_Map_Test.current_implementation/iteration:65: 6.76ms +Primitive_Bi_Map_Test.current_implementation/iteration:66: 4.8ms +Primitive_Bi_Map_Test.current_implementation/iteration:67: 4.78ms +Primitive_Bi_Map_Test.current_implementation/iteration:68: 7.26ms +Primitive_Bi_Map_Test.current_implementation/iteration:69: 6.78ms +Primitive_Bi_Map_Test.current_implementation/iteration:70: 5.81ms +Primitive_Bi_Map_Test.current_implementation/iteration:71: 6.36ms +Primitive_Bi_Map_Test.current_implementation/iteration:72: 4.79ms +Primitive_Bi_Map_Test.current_implementation/iteration:73: 6.55ms +Primitive_Bi_Map_Test.current_implementation/iteration:74: 7ms +Primitive_Bi_Map_Test.current_implementation/iteration:75: 5.57ms +Primitive_Bi_Map_Test.current_implementation/iteration:76: 7.06ms +Primitive_Bi_Map_Test.current_implementation/iteration:77: 6.63ms +Primitive_Bi_Map_Test.current_implementation/iteration:78: 5.54ms +Primitive_Bi_Map_Test.current_implementation/iteration:79: 5.93ms +Primitive_Bi_Map_Test.current_implementation/iteration:80: 4.8ms +Primitive_Bi_Map_Test.current_implementation/iteration:81: 7.07ms +Primitive_Bi_Map_Test.current_implementation/iteration:82: 6.73ms +Primitive_Bi_Map_Test.current_implementation/iteration:83: 6.99ms +Primitive_Bi_Map_Test.current_implementation/iteration:84: 6.63ms +Primitive_Bi_Map_Test.current_implementation/iteration:85: 7.24ms +Primitive_Bi_Map_Test.current_implementation/iteration:86: 7.47ms +Primitive_Bi_Map_Test.current_implementation/iteration:87: 7.48ms +Primitive_Bi_Map_Test.current_implementation/iteration:88: 6.7ms +Primitive_Bi_Map_Test.current_implementation/iteration:89: 7.17ms +Primitive_Bi_Map_Test.current_implementation/iteration:90: 8.1ms +Primitive_Bi_Map_Test.current_implementation/iteration:91: 6.04ms +Primitive_Bi_Map_Test.current_implementation/iteration:92: 7.54ms +Primitive_Bi_Map_Test.current_implementation/iteration:93: 5.12ms +Primitive_Bi_Map_Test.current_implementation/iteration:94: 6.41ms +Primitive_Bi_Map_Test.current_implementation/iteration:95: 7.3ms +Primitive_Bi_Map_Test.current_implementation/iteration:96: 10.62ms +Primitive_Bi_Map_Test.current_implementation/iteration:97: 7.1ms +Primitive_Bi_Map_Test.current_implementation/iteration:98: 7.12ms +Primitive_Bi_Map_Test.current_implementation/iteration:99: 6.98ms +Primitive_Bi_Map_Test.current_implementation average: 7.01ms +Primitive_Bi_Map_Test.java_map/iteration:0: 15.5ms +Primitive_Bi_Map_Test.java_map/iteration:1: 3.67ms +Primitive_Bi_Map_Test.java_map/iteration:2: 3.65ms +Primitive_Bi_Map_Test.java_map/iteration:3: 3.67ms +Primitive_Bi_Map_Test.java_map/iteration:4: 3.36ms +Primitive_Bi_Map_Test.java_map/iteration:5: 3.34ms +Primitive_Bi_Map_Test.java_map/iteration:6: 2.19ms +Primitive_Bi_Map_Test.java_map/iteration:7: 3.2ms +Primitive_Bi_Map_Test.java_map/iteration:8: 3.32ms +Primitive_Bi_Map_Test.java_map/iteration:9: 3.67ms +Primitive_Bi_Map_Test.java_map/iteration:10: 3.3ms +Primitive_Bi_Map_Test.java_map/iteration:11: 3.32ms +Primitive_Bi_Map_Test.java_map/iteration:12: 3.31ms +Primitive_Bi_Map_Test.java_map/iteration:13: 3.45ms +Primitive_Bi_Map_Test.java_map/iteration:14: 3.41ms +Primitive_Bi_Map_Test.java_map/iteration:15: 3.3ms +Primitive_Bi_Map_Test.java_map/iteration:16: 3.26ms +Primitive_Bi_Map_Test.java_map/iteration:17: 3.36ms +Primitive_Bi_Map_Test.java_map/iteration:18: 3.73ms +Primitive_Bi_Map_Test.java_map/iteration:19: 3.26ms +Primitive_Bi_Map_Test.java_map/iteration:20: 3.38ms +Primitive_Bi_Map_Test.java_map/iteration:21: 3.31ms +Primitive_Bi_Map_Test.java_map/iteration:22: 3.79ms +Primitive_Bi_Map_Test.java_map/iteration:23: 2.35ms +Primitive_Bi_Map_Test.java_map/iteration:24: 3.22ms +Primitive_Bi_Map_Test.java_map/iteration:25: 3.18ms +Primitive_Bi_Map_Test.java_map/iteration:26: 3.24ms +Primitive_Bi_Map_Test.java_map/iteration:27: 3.53ms +Primitive_Bi_Map_Test.java_map/iteration:28: 3.17ms +Primitive_Bi_Map_Test.java_map/iteration:29: 3.09ms +Primitive_Bi_Map_Test.java_map/iteration:30: 3.17ms +Primitive_Bi_Map_Test.java_map/iteration:31: 3.58ms +Primitive_Bi_Map_Test.java_map/iteration:32: 3.56ms +Primitive_Bi_Map_Test.java_map/iteration:33: 3.14ms +Primitive_Bi_Map_Test.java_map/iteration:34: 3.13ms +Primitive_Bi_Map_Test.java_map/iteration:35: 3.19ms +Primitive_Bi_Map_Test.java_map/iteration:36: 2.79ms +Primitive_Bi_Map_Test.java_map/iteration:37: 3.67ms +Primitive_Bi_Map_Test.java_map/iteration:38: 3.43ms +Primitive_Bi_Map_Test.java_map/iteration:39: 3.37ms +Primitive_Bi_Map_Test.java_map/iteration:40: 3.7ms +Primitive_Bi_Map_Test.java_map/iteration:41: 2.83ms +Primitive_Bi_Map_Test.java_map/iteration:42: 3.77ms +Primitive_Bi_Map_Test.java_map/iteration:43: 3.47ms +Primitive_Bi_Map_Test.java_map/iteration:44: 3.73ms +Primitive_Bi_Map_Test.java_map/iteration:45: 3.96ms +Primitive_Bi_Map_Test.java_map/iteration:46: 3.69ms +Primitive_Bi_Map_Test.java_map/iteration:47: 3.53ms +Primitive_Bi_Map_Test.java_map/iteration:48: 3.49ms +Primitive_Bi_Map_Test.java_map/iteration:49: 3.63ms +Primitive_Bi_Map_Test.java_map/iteration:50: 3.74ms +Primitive_Bi_Map_Test.java_map/iteration:51: 3.28ms +Primitive_Bi_Map_Test.java_map/iteration:52: 3.65ms +Primitive_Bi_Map_Test.java_map/iteration:53: 3.62ms +Primitive_Bi_Map_Test.java_map/iteration:54: 2.34ms +Primitive_Bi_Map_Test.java_map/iteration:55: 3.57ms +Primitive_Bi_Map_Test.java_map/iteration:56: 3.35ms +Primitive_Bi_Map_Test.java_map/iteration:57: 3.19ms +Primitive_Bi_Map_Test.java_map/iteration:58: 3.43ms +Primitive_Bi_Map_Test.java_map/iteration:59: 3.65ms +Primitive_Bi_Map_Test.java_map/iteration:60: 3.62ms +Primitive_Bi_Map_Test.java_map/iteration:61: 3.18ms +Primitive_Bi_Map_Test.java_map/iteration:62: 3.08ms +Primitive_Bi_Map_Test.java_map/iteration:63: 3.5ms +Primitive_Bi_Map_Test.java_map/iteration:64: 2.39ms +Primitive_Bi_Map_Test.java_map/iteration:65: 3.36ms +Primitive_Bi_Map_Test.java_map/iteration:66: 3.2ms +Primitive_Bi_Map_Test.java_map/iteration:67: 3.36ms +Primitive_Bi_Map_Test.java_map/iteration:68: 3.43ms +Primitive_Bi_Map_Test.java_map/iteration:69: 3.7ms +Primitive_Bi_Map_Test.java_map/iteration:70: 3.54ms +Primitive_Bi_Map_Test.java_map/iteration:71: 3.34ms +Primitive_Bi_Map_Test.java_map/iteration:72: 3.35ms +Primitive_Bi_Map_Test.java_map/iteration:73: 3.74ms +Primitive_Bi_Map_Test.java_map/iteration:74: 3.34ms +Primitive_Bi_Map_Test.java_map/iteration:75: 3.35ms +Primitive_Bi_Map_Test.java_map/iteration:76: 3.49ms +Primitive_Bi_Map_Test.java_map/iteration:77: 3.83ms +Primitive_Bi_Map_Test.java_map/iteration:78: 3.56ms +Primitive_Bi_Map_Test.java_map/iteration:79: 3.46ms +Primitive_Bi_Map_Test.java_map/iteration:80: 3.47ms +Primitive_Bi_Map_Test.java_map/iteration:81: 3.69ms +Primitive_Bi_Map_Test.java_map/iteration:82: 3.79ms +Primitive_Bi_Map_Test.java_map/iteration:83: 3.53ms +Primitive_Bi_Map_Test.java_map/iteration:84: 3.1ms +Primitive_Bi_Map_Test.java_map/iteration:85: 3.8ms +Primitive_Bi_Map_Test.java_map/iteration:86: 3.98ms +Primitive_Bi_Map_Test.java_map/iteration:87: 3.54ms +Primitive_Bi_Map_Test.java_map/iteration:88: 3.66ms +Primitive_Bi_Map_Test.java_map/iteration:89: 3.71ms +Primitive_Bi_Map_Test.java_map/iteration:90: 3.71ms +Primitive_Bi_Map_Test.java_map/iteration:91: 3.54ms +Primitive_Bi_Map_Test.java_map/iteration:92: 3.65ms +Primitive_Bi_Map_Test.java_map/iteration:93: 3.63ms +Primitive_Bi_Map_Test.java_map/iteration:94: 4.19ms +Primitive_Bi_Map_Test.java_map/iteration:95: 3.73ms +Primitive_Bi_Map_Test.java_map/iteration:96: 3.84ms +Primitive_Bi_Map_Test.java_map/iteration:97: 3.75ms +Primitive_Bi_Map_Test.java_map/iteration:98: 4.13ms +Primitive_Bi_Map_Test.java_map/iteration:99: 3.81ms +Primitive_Bi_Map_Test.java_map average: 3.56ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:0: 425.79ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:1: 387.16ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:2: 371.36ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:3: 341ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:4: 477.92ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:5: 311.18ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:6: 287.21ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:7: 267.66ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:8: 223.71ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:9: 186.88ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:10: 168.63ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:11: 310.09ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:12: 195.11ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:13: 167.14ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:14: 232.88ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:15: 220.85ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:16: 164.53ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:17: 173.17ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:18: 248.99ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:19: 250.78ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:20: 200.61ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:21: 166.98ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:22: 177.66ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:23: 235.33ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:24: 170.83ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:25: 166.71ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:26: 166.88ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:27: 235.6ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:28: 204.63ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:29: 213.3ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:30: 207.42ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:31: 200.95ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:32: 203.69ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:33: 204.53ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:34: 203.96ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:35: 205.91ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:36: 223.67ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:37: 200.36ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:38: 243.31ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:39: 147.3ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:40: 142.58ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:41: 135.95ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:42: 146.52ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:43: 146.34ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:44: 139.67ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:45: 138.31ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:46: 142.23ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:47: 135.94ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:48: 143.16ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:49: 230.88ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:50: 142.99ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:51: 140.63ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:52: 141.57ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:53: 138.12ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:54: 138.24ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:55: 138.43ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:56: 138.96ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:57: 139.68ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:58: 222.45ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:59: 140.02ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:60: 141.92ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:61: 135.65ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:62: 138.63ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:63: 143.05ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:64: 138.52ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:65: 140.86ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:66: 215.51ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:67: 151.35ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:68: 134.75ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:69: 150.36ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:70: 142.44ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:71: 142.12ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:72: 137.03ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:73: 137.32ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:74: 206.29ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:75: 144.89ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:76: 141.01ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:77: 142.07ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:78: 136.8ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:79: 142.02ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:80: 134.52ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:81: 203.87ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:82: 148.94ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:83: 145.02ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:84: 138.24ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:85: 139.4ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:86: 146.48ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:87: 210.77ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:88: 149.66ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:89: 144.89ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:90: 140.97ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:91: 139.45ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:92: 191.67ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:93: 137.18ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:94: 142.12ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:95: 141.04ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:96: 137.51ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:97: 185.22ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:98: 136.98ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:99: 145.27ms +Primitive_Bi_Map_Test.enso_map_as_vector+date_conversion average: 183.96ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:0: 79.64ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:1: 119.73ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:2: 83.83ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:3: 82.88ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:4: 95.86ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:5: 86.3ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:6: 115.26ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:7: 81.55ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:8: 80.47ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:9: 81.01ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:10: 120.93ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:11: 88.22ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:12: 80.98ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:13: 110.5ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:14: 93.37ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:15: 81.23ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:16: 112.48ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:17: 86.22ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:18: 80.36ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:19: 147.62ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:20: 134.11ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:21: 82.2ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:22: 82.09ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:23: 166.41ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:24: 93.27ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:25: 83.93ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:26: 86.77ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:27: 86.6ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:28: 84.13ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:29: 90.47ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:30: 116.87ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:31: 91.43ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:32: 80.5ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:33: 82.13ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:34: 80.29ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:35: 85.69ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:36: 142.86ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:37: 85.39ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:38: 83.41ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:39: 78ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:40: 84.99ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:41: 127.25ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:42: 113.76ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:43: 140.55ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:44: 136.73ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:45: 136.04ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:46: 139.29ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:47: 114.96ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:48: 79.18ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:49: 139.92ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:50: 84.27ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:51: 85.11ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:52: 79.87ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:53: 86ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:54: 121.92ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:55: 89.26ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:56: 147.73ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:57: 84.19ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:58: 81.37ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:59: 83.36ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:60: 83.21ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:61: 82.18ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:62: 85.97ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:63: 160.44ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:64: 82.23ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:65: 84.41ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:66: 83.64ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:67: 84.17ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:68: 128.27ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:69: 103.86ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:70: 81.25ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:71: 81.39ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:72: 81.79ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:73: 127.63ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:74: 127.2ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:75: 129.12ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:76: 84.47ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:77: 87.22ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:78: 80.54ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:79: 131.64ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:80: 86.9ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:81: 86.6ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:82: 79.33ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:83: 122.68ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:84: 108.51ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:85: 87.94ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:86: 81.68ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:87: 84.75ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:88: 128.59ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:89: 82.36ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:90: 86.62ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:91: 117.88ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:92: 136.37ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:93: 118.95ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:94: 94.94ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:95: 84.73ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:96: 177.28ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:97: 84.73ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:98: 82.57ms +Primitive_Bi_Map_Test.enso_map_as_vector/iteration:99: 83.71ms +Primitive_Bi_Map_Test.enso_map_as_vector average: 99.88ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:0: 199.86ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:1: 455.89ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:2: 262.3ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:3: 238.75ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:4: 278.91ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:5: 104.89ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:6: 107.69ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:7: 104.32ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:8: 103.78ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:9: 108.13ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:10: 106.32ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:11: 103.96ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:12: 105.42ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:13: 105.28ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:14: 100.81ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:15: 105.87ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:16: 108.21ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:17: 107.05ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:18: 99.54ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:19: 99.44ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:20: 110.39ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:21: 102.51ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:22: 100.11ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:23: 115.69ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:24: 113.41ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:25: 99.24ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:26: 101.81ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:27: 103.16ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:28: 101.59ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:29: 104.27ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:30: 104.94ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:31: 99.03ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:32: 104.51ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:33: 104.12ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:34: 98.8ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:35: 110.54ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:36: 134.06ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:37: 103.03ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:38: 103.54ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:39: 100.07ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:40: 101.06ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:41: 102.84ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:42: 103.13ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:43: 98.12ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:44: 104.04ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:45: 107.06ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:46: 112.14ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:47: 98.68ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:48: 107.6ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:49: 104.24ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:50: 101.9ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:51: 101.55ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:52: 101.99ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:53: 104.43ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:54: 103.68ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:55: 103.08ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:56: 105.65ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:57: 103.68ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:58: 102.49ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:59: 100.87ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:60: 130.32ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:61: 108.12ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:62: 101.92ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:63: 101.4ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:64: 100.31ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:65: 102.88ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:66: 102.3ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:67: 102.07ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:68: 101.74ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:69: 108.2ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:70: 100.71ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:71: 101.36ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:72: 104.25ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:73: 101.87ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:74: 101.67ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:75: 102.51ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:76: 104.3ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:77: 130.62ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:78: 102.1ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:79: 99.11ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:80: 108.09ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:81: 107.57ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:82: 100.57ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:83: 100.16ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:84: 99.31ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:85: 101.99ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:86: 100.08ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:87: 99.07ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:88: 101.13ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:89: 133.27ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:90: 101.04ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:91: 102.34ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:92: 104.98ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:93: 98.88ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:94: 100.9ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:95: 99.62ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:96: 100.46ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:97: 101.34ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:98: 103.73ms +Primitive_Bi_Map_Test.enso_map_with_builder/iteration:99: 132.32ms +Primitive_Bi_Map_Test.enso_map_with_builder average: 113.94ms +Boxed_Bi_Map_Test.current_implementation/iteration:0: 29.27ms +Boxed_Bi_Map_Test.current_implementation/iteration:1: 23.57ms +Boxed_Bi_Map_Test.current_implementation/iteration:2: 26.94ms +Boxed_Bi_Map_Test.current_implementation/iteration:3: 29.53ms +Boxed_Bi_Map_Test.current_implementation/iteration:4: 38.08ms +Boxed_Bi_Map_Test.current_implementation/iteration:5: 39.63ms +Boxed_Bi_Map_Test.current_implementation/iteration:6: 23.31ms +Boxed_Bi_Map_Test.current_implementation/iteration:7: 36.18ms +Boxed_Bi_Map_Test.current_implementation/iteration:8: 23.68ms +Boxed_Bi_Map_Test.current_implementation/iteration:9: 24.77ms +Boxed_Bi_Map_Test.current_implementation/iteration:10: 26.6ms +Boxed_Bi_Map_Test.current_implementation/iteration:11: 27.33ms +Boxed_Bi_Map_Test.current_implementation/iteration:12: 41.13ms +Boxed_Bi_Map_Test.current_implementation/iteration:13: 39.8ms +Boxed_Bi_Map_Test.current_implementation/iteration:14: 26.72ms +Boxed_Bi_Map_Test.current_implementation/iteration:15: 23.32ms +Boxed_Bi_Map_Test.current_implementation/iteration:16: 29.57ms +Boxed_Bi_Map_Test.current_implementation/iteration:17: 23.22ms +Boxed_Bi_Map_Test.current_implementation/iteration:18: 25.76ms +Boxed_Bi_Map_Test.current_implementation/iteration:19: 27ms +Boxed_Bi_Map_Test.current_implementation/iteration:20: 25.71ms +Boxed_Bi_Map_Test.current_implementation/iteration:21: 26.07ms +Boxed_Bi_Map_Test.current_implementation/iteration:22: 28.7ms +Boxed_Bi_Map_Test.current_implementation/iteration:23: 37.93ms +Boxed_Bi_Map_Test.current_implementation/iteration:24: 37.67ms +Boxed_Bi_Map_Test.current_implementation/iteration:25: 38.41ms +Boxed_Bi_Map_Test.current_implementation/iteration:26: 315.17ms +Boxed_Bi_Map_Test.current_implementation/iteration:27: 54.63ms +Boxed_Bi_Map_Test.current_implementation/iteration:28: 55ms +Boxed_Bi_Map_Test.current_implementation/iteration:29: 54.3ms +Boxed_Bi_Map_Test.current_implementation/iteration:30: 52.89ms +Boxed_Bi_Map_Test.current_implementation/iteration:31: 47.11ms +Boxed_Bi_Map_Test.current_implementation/iteration:32: 55.43ms +Boxed_Bi_Map_Test.current_implementation/iteration:33: 72.88ms +Boxed_Bi_Map_Test.current_implementation/iteration:34: 46.62ms +Boxed_Bi_Map_Test.current_implementation/iteration:35: 40.89ms +Boxed_Bi_Map_Test.current_implementation/iteration:36: 50.38ms +Boxed_Bi_Map_Test.current_implementation/iteration:37: 47.66ms +Boxed_Bi_Map_Test.current_implementation/iteration:38: 160.33ms +Boxed_Bi_Map_Test.current_implementation/iteration:39: 57.54ms +Boxed_Bi_Map_Test.current_implementation/iteration:40: 51.14ms +Boxed_Bi_Map_Test.current_implementation/iteration:41: 40.39ms +Boxed_Bi_Map_Test.current_implementation/iteration:42: 50.42ms +Boxed_Bi_Map_Test.current_implementation/iteration:43: 42.85ms +Boxed_Bi_Map_Test.current_implementation/iteration:44: 26.47ms +Boxed_Bi_Map_Test.current_implementation/iteration:45: 25.36ms +Boxed_Bi_Map_Test.current_implementation/iteration:46: 25.42ms +Boxed_Bi_Map_Test.current_implementation/iteration:47: 24.13ms +Boxed_Bi_Map_Test.current_implementation/iteration:48: 24.52ms +Boxed_Bi_Map_Test.current_implementation/iteration:49: 123.08ms +Boxed_Bi_Map_Test.current_implementation/iteration:50: 26.69ms +Boxed_Bi_Map_Test.current_implementation/iteration:51: 74.46ms +Boxed_Bi_Map_Test.current_implementation/iteration:52: 24.64ms +Boxed_Bi_Map_Test.current_implementation/iteration:53: 25.26ms +Boxed_Bi_Map_Test.current_implementation/iteration:54: 35.91ms +Boxed_Bi_Map_Test.current_implementation/iteration:55: 25.2ms +Boxed_Bi_Map_Test.current_implementation/iteration:56: 76.55ms +Boxed_Bi_Map_Test.current_implementation/iteration:57: 54.08ms +Boxed_Bi_Map_Test.current_implementation/iteration:58: 30.72ms +Boxed_Bi_Map_Test.current_implementation/iteration:59: 38.87ms +Boxed_Bi_Map_Test.current_implementation/iteration:60: 77.9ms +Boxed_Bi_Map_Test.current_implementation/iteration:61: 103.62ms +Boxed_Bi_Map_Test.current_implementation/iteration:62: 76.46ms +Boxed_Bi_Map_Test.current_implementation/iteration:63: 60.25ms +Boxed_Bi_Map_Test.current_implementation/iteration:64: 77.76ms +Boxed_Bi_Map_Test.current_implementation/iteration:65: 77.45ms +Boxed_Bi_Map_Test.current_implementation/iteration:66: 73.62ms +Boxed_Bi_Map_Test.current_implementation/iteration:67: 60.09ms +Boxed_Bi_Map_Test.current_implementation/iteration:68: 40.18ms +Boxed_Bi_Map_Test.current_implementation/iteration:69: 54.77ms +Boxed_Bi_Map_Test.current_implementation/iteration:70: 122.64ms +Boxed_Bi_Map_Test.current_implementation/iteration:71: 28.53ms +Boxed_Bi_Map_Test.current_implementation/iteration:72: 61.48ms +Boxed_Bi_Map_Test.current_implementation/iteration:73: 33.38ms +Boxed_Bi_Map_Test.current_implementation/iteration:74: 26.03ms +Boxed_Bi_Map_Test.current_implementation/iteration:75: 23.63ms +Boxed_Bi_Map_Test.current_implementation/iteration:76: 28.53ms +Boxed_Bi_Map_Test.current_implementation/iteration:77: 28.96ms +Boxed_Bi_Map_Test.current_implementation/iteration:78: 25.01ms +Boxed_Bi_Map_Test.current_implementation/iteration:79: 26.56ms +Boxed_Bi_Map_Test.current_implementation/iteration:80: 30.87ms +Boxed_Bi_Map_Test.current_implementation/iteration:81: 22.78ms +Boxed_Bi_Map_Test.current_implementation/iteration:82: 97.85ms +Boxed_Bi_Map_Test.current_implementation/iteration:83: 24.76ms +Boxed_Bi_Map_Test.current_implementation/iteration:84: 25.61ms +Boxed_Bi_Map_Test.current_implementation/iteration:85: 24.58ms +Boxed_Bi_Map_Test.current_implementation/iteration:86: 27.55ms +Boxed_Bi_Map_Test.current_implementation/iteration:87: 23.74ms +Boxed_Bi_Map_Test.current_implementation/iteration:88: 89.15ms +Boxed_Bi_Map_Test.current_implementation/iteration:89: 46.76ms +Boxed_Bi_Map_Test.current_implementation/iteration:90: 44.39ms +Boxed_Bi_Map_Test.current_implementation/iteration:91: 41.73ms +Boxed_Bi_Map_Test.current_implementation/iteration:92: 100.76ms +Boxed_Bi_Map_Test.current_implementation/iteration:93: 47.07ms +Boxed_Bi_Map_Test.current_implementation/iteration:94: 36.49ms +Boxed_Bi_Map_Test.current_implementation/iteration:95: 36.48ms +Boxed_Bi_Map_Test.current_implementation/iteration:96: 27.49ms +Boxed_Bi_Map_Test.current_implementation/iteration:97: 24.97ms +Boxed_Bi_Map_Test.current_implementation/iteration:98: 34.1ms +Boxed_Bi_Map_Test.current_implementation/iteration:99: 26.12ms +Boxed_Bi_Map_Test.current_implementation average: 46.77ms +Boxed_Bi_Map_Test.java_map/iteration:0: 38.94ms +Boxed_Bi_Map_Test.java_map/iteration:1: 25.03ms +Boxed_Bi_Map_Test.java_map/iteration:2: 22.37ms +Boxed_Bi_Map_Test.java_map/iteration:3: 25.19ms +Boxed_Bi_Map_Test.java_map/iteration:4: 110.18ms +Boxed_Bi_Map_Test.java_map/iteration:5: 22.08ms +Boxed_Bi_Map_Test.java_map/iteration:6: 76.9ms +Boxed_Bi_Map_Test.java_map/iteration:7: 51.36ms +Boxed_Bi_Map_Test.java_map/iteration:8: 38.03ms +Boxed_Bi_Map_Test.java_map/iteration:9: 37.74ms +Boxed_Bi_Map_Test.java_map/iteration:10: 38.08ms +Boxed_Bi_Map_Test.java_map/iteration:11: 36.79ms +Boxed_Bi_Map_Test.java_map/iteration:12: 37.5ms +Boxed_Bi_Map_Test.java_map/iteration:13: 36.19ms +Boxed_Bi_Map_Test.java_map/iteration:14: 33.58ms +Boxed_Bi_Map_Test.java_map/iteration:15: 33.24ms +Boxed_Bi_Map_Test.java_map/iteration:16: 33ms +Boxed_Bi_Map_Test.java_map/iteration:17: 30.3ms +Boxed_Bi_Map_Test.java_map/iteration:18: 32.03ms +Boxed_Bi_Map_Test.java_map/iteration:19: 30.36ms +Boxed_Bi_Map_Test.java_map/iteration:20: 32.36ms +Boxed_Bi_Map_Test.java_map/iteration:21: 30.97ms +Boxed_Bi_Map_Test.java_map/iteration:22: 151.3ms +Boxed_Bi_Map_Test.java_map/iteration:23: 36.07ms +Boxed_Bi_Map_Test.java_map/iteration:24: 27.62ms +Boxed_Bi_Map_Test.java_map/iteration:25: 28.51ms +Boxed_Bi_Map_Test.java_map/iteration:26: 23.82ms +Boxed_Bi_Map_Test.java_map/iteration:27: 22.52ms +Boxed_Bi_Map_Test.java_map/iteration:28: 19.22ms +Boxed_Bi_Map_Test.java_map/iteration:29: 22.95ms +Boxed_Bi_Map_Test.java_map/iteration:30: 22.74ms +Boxed_Bi_Map_Test.java_map/iteration:31: 23ms +Boxed_Bi_Map_Test.java_map/iteration:32: 22.43ms +Boxed_Bi_Map_Test.java_map/iteration:33: 119.31ms +Boxed_Bi_Map_Test.java_map/iteration:34: 68.92ms +Boxed_Bi_Map_Test.java_map/iteration:35: 36.46ms +Boxed_Bi_Map_Test.java_map/iteration:36: 37.41ms +Boxed_Bi_Map_Test.java_map/iteration:37: 44.97ms +Boxed_Bi_Map_Test.java_map/iteration:38: 35.32ms +Boxed_Bi_Map_Test.java_map/iteration:39: 41.11ms +Boxed_Bi_Map_Test.java_map/iteration:40: 81.98ms +Boxed_Bi_Map_Test.java_map/iteration:41: 27.58ms +Boxed_Bi_Map_Test.java_map/iteration:42: 84.77ms +Boxed_Bi_Map_Test.java_map/iteration:43: 25.57ms +Boxed_Bi_Map_Test.java_map/iteration:44: 46.18ms +Boxed_Bi_Map_Test.java_map/iteration:45: 37.5ms +Boxed_Bi_Map_Test.java_map/iteration:46: 36.23ms +Boxed_Bi_Map_Test.java_map/iteration:47: 38.79ms +Boxed_Bi_Map_Test.java_map/iteration:48: 34.98ms +Boxed_Bi_Map_Test.java_map/iteration:49: 35.07ms +Boxed_Bi_Map_Test.java_map/iteration:50: 33.68ms +Boxed_Bi_Map_Test.java_map/iteration:51: 33.41ms +Boxed_Bi_Map_Test.java_map/iteration:52: 26.07ms +Boxed_Bi_Map_Test.java_map/iteration:53: 19.8ms +Boxed_Bi_Map_Test.java_map/iteration:54: 19.64ms +Boxed_Bi_Map_Test.java_map/iteration:55: 19.69ms +Boxed_Bi_Map_Test.java_map/iteration:56: 19.71ms +Boxed_Bi_Map_Test.java_map/iteration:57: 19.36ms +Boxed_Bi_Map_Test.java_map/iteration:58: 20.79ms +Boxed_Bi_Map_Test.java_map/iteration:59: 19.75ms +Boxed_Bi_Map_Test.java_map/iteration:60: 19.23ms +Boxed_Bi_Map_Test.java_map/iteration:61: 21.17ms +Boxed_Bi_Map_Test.java_map/iteration:62: 22.52ms +Boxed_Bi_Map_Test.java_map/iteration:63: 20.46ms +Boxed_Bi_Map_Test.java_map/iteration:64: 15.99ms +Boxed_Bi_Map_Test.java_map/iteration:65: 16.07ms +Boxed_Bi_Map_Test.java_map/iteration:66: 203.05ms +Boxed_Bi_Map_Test.java_map/iteration:67: 75.76ms +Boxed_Bi_Map_Test.java_map/iteration:68: 46.59ms +Boxed_Bi_Map_Test.java_map/iteration:69: 45.72ms +Boxed_Bi_Map_Test.java_map/iteration:70: 67.77ms +Boxed_Bi_Map_Test.java_map/iteration:71: 73.83ms +Boxed_Bi_Map_Test.java_map/iteration:72: 44.74ms +Boxed_Bi_Map_Test.java_map/iteration:73: 33.3ms +Boxed_Bi_Map_Test.java_map/iteration:74: 29.27ms +Boxed_Bi_Map_Test.java_map/iteration:75: 33.39ms +Boxed_Bi_Map_Test.java_map/iteration:76: 28.03ms +Boxed_Bi_Map_Test.java_map/iteration:77: 21.29ms +Boxed_Bi_Map_Test.java_map/iteration:78: 21.28ms +Boxed_Bi_Map_Test.java_map/iteration:79: 21.4ms +Boxed_Bi_Map_Test.java_map/iteration:80: 20.84ms +Boxed_Bi_Map_Test.java_map/iteration:81: 21.16ms +Boxed_Bi_Map_Test.java_map/iteration:82: 133.92ms +Boxed_Bi_Map_Test.java_map/iteration:83: 54.81ms +Boxed_Bi_Map_Test.java_map/iteration:84: 89.94ms +Boxed_Bi_Map_Test.java_map/iteration:85: 52.03ms +Boxed_Bi_Map_Test.java_map/iteration:86: 41.91ms +Boxed_Bi_Map_Test.java_map/iteration:87: 45.1ms +Boxed_Bi_Map_Test.java_map/iteration:88: 33.34ms +Boxed_Bi_Map_Test.java_map/iteration:89: 23.58ms +Boxed_Bi_Map_Test.java_map/iteration:90: 23.87ms +Boxed_Bi_Map_Test.java_map/iteration:91: 22.54ms +Boxed_Bi_Map_Test.java_map/iteration:92: 22.56ms +Boxed_Bi_Map_Test.java_map/iteration:93: 25ms +Boxed_Bi_Map_Test.java_map/iteration:94: 21.03ms +Boxed_Bi_Map_Test.java_map/iteration:95: 23.09ms +Boxed_Bi_Map_Test.java_map/iteration:96: 22.13ms +Boxed_Bi_Map_Test.java_map/iteration:97: 23.13ms +Boxed_Bi_Map_Test.java_map/iteration:98: 22.38ms +Boxed_Bi_Map_Test.java_map/iteration:99: 22.52ms +Boxed_Bi_Map_Test.java_map average: 39.22ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:0: 598.06ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:1: 353.91ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:2: 332.9ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:3: 320.99ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:4: 350.91ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:5: 367.41ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:6: 377.29ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:7: 367.65ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:8: 366.88ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:9: 528.67ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:10: 235.05ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:11: 358.23ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:12: 357.14ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:13: 220.48ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:14: 450.24ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:15: 357.73ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:16: 347.29ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:17: 367.59ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:18: 512.92ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:19: 394.88ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:20: 244.74ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:21: 214.65ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:22: 461.55ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:23: 367.56ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:24: 207.14ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:25: 335.48ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:26: 413.86ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:27: 318.77ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:28: 314.16ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:29: 321.04ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:30: 262.15ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:31: 552.32ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:32: 298.1ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:33: 183.3ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:34: 181.41ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:35: 466.76ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:36: 322.27ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:37: 196.91ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:38: 341.59ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:39: 411.7ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:40: 323.85ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:41: 317.74ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:42: 313.8ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:43: 492.52ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:44: 343.27ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:45: 227.93ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:46: 189.98ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:47: 183.79ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:48: 451.96ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:49: 321.8ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:50: 228.27ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:51: 195.47ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:52: 473.53ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:53: 330.61ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:54: 318.95ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:55: 311.49ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:56: 319.19ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:57: 453.07ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:58: 357.89ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:59: 247.96ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:60: 201.66ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:61: 207.29ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:62: 432.6ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:63: 297.8ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:64: 215.95ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:65: 189.2ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:66: 426.53ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:67: 377.58ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:68: 327.52ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:69: 318.78ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:70: 333.98ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:71: 465.73ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:72: 459.87ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:73: 207.9ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:74: 192.41ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:75: 182.62ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:76: 483.79ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:77: 294.61ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:78: 214.84ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:79: 191.72ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:80: 512.25ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:81: 321.39ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:82: 325.64ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:83: 333.81ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:84: 311.48ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:85: 446.9ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:86: 359.42ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:87: 252.79ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:88: 193.06ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:89: 208.01ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:90: 449.54ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:91: 306.51ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:92: 203.51ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:93: 335.59ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:94: 331.84ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:95: 331.09ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:96: 320.05ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:97: 329.31ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:98: 321.81ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion/iteration:99: 585.23ms +Boxed_Bi_Map_Test.enso_map_as_vector+date_conversion average: 331.86ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:0: 261.03ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:1: 181.49ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:2: 169.07ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:3: 164.6ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:4: 479.58ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:5: 203.5ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:6: 176.77ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:7: 428.3ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:8: 238.36ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:9: 170.53ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:10: 313.31ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:11: 313.8ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:12: 181.39ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:13: 319.27ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:14: 293.62ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:15: 177.36ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:16: 161.84ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:17: 341.43ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:18: 278.48ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:19: 191.79ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:20: 341.16ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:21: 287.75ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:22: 180.25ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:23: 154.67ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:24: 355.53ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:25: 292.73ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:26: 175.39ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:27: 324.34ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:28: 333.93ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:29: 174.31ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:30: 157.66ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:31: 359.08ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:32: 266.6ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:33: 175.55ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:34: 290.82ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:35: 280.7ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:36: 260.29ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:37: 262.86ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:38: 256.3ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:39: 264.33ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:40: 521.63ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:41: 295.38ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:42: 221.73ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:43: 173.04ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:44: 170.03ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:45: 160.51ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:46: 449.71ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:47: 368.4ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:48: 171.89ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:49: 175.58ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:50: 362.84ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:51: 304.97ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:52: 195.66ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:53: 312.33ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:54: 311.05ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:55: 262.39ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:56: 255.16ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:57: 259.35ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:58: 270.95ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:59: 540.06ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:60: 249.5ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:61: 185.28ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:62: 171.98ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:63: 166.19ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:64: 482.23ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:65: 252.56ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:66: 178.18ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:67: 182.76ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:68: 408.08ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:69: 266.17ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:70: 184.68ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:71: 329.67ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:72: 282.25ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:73: 272ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:74: 252.86ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:75: 251.21ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:76: 245.89ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:77: 488.22ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:78: 314.97ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:79: 172.14ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:80: 171.54ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:81: 152.83ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:82: 493.35ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:83: 277.2ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:84: 176.92ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:85: 167.49ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:86: 356.53ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:87: 290.12ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:88: 188.8ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:89: 344.3ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:90: 290.48ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:91: 277.68ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:92: 262.04ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:93: 267.19ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:94: 261.92ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:95: 544.06ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:96: 259.93ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:97: 192.05ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:98: 163.86ms +Boxed_Bi_Map_Test.enso_map_as_vector/iteration:99: 146.91ms +Boxed_Bi_Map_Test.enso_map_as_vector average: 266.44ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:0: 859.17ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:1: 408.51ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:2: 425.57ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:3: 334.2ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:4: 139.77ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:5: 276.58ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:6: 280.57ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:7: 162.55ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:8: 143.38ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:9: 250.33ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:10: 221.08ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:11: 263.77ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:12: 160.06ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:13: 134.45ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:14: 128.5ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:15: 263.9ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:16: 232.62ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:17: 169.35ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:18: 143.79ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:19: 284.62ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:20: 191.03ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:21: 207.22ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:22: 209.33ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:23: 211.52ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:24: 227.67ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:25: 207.9ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:26: 200.82ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:27: 213.86ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:28: 403.49ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:29: 335.32ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:30: 181.09ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:31: 159.91ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:32: 162.86ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:33: 140.49ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:34: 131.99ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:35: 127.18ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:36: 361.56ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:37: 236.41ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:38: 166.64ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:39: 145.23ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:40: 134.16ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:41: 262.45ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:42: 241.91ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:43: 204.74ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:44: 207.1ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:45: 203.64ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:46: 234.94ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:47: 200.84ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:48: 192.18ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:49: 200.53ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:50: 204.44ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:51: 380.5ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:52: 328.67ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:53: 182.11ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:54: 153.63ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:55: 162.56ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:56: 148.01ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:57: 138.3ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:58: 136.88ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:59: 324.6ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:60: 292.48ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:61: 165.15ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:62: 144.86ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:63: 135.19ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:64: 259.52ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:65: 288.8ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:66: 219.99ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:67: 221.88ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:68: 208.67ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:69: 205.07ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:70: 234.49ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:71: 215.72ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:72: 202.84ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:73: 201.77ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:74: 394.06ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:75: 295.7ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:76: 194.11ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:77: 162.1ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:78: 149.41ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:79: 145.07ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:80: 141.35ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:81: 133.58ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:82: 358.18ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:83: 279.14ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:84: 162.53ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:85: 152.22ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:86: 134.36ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:87: 247.03ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:88: 251.33ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:89: 231.54ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:90: 213.89ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:91: 205.19ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:92: 203.84ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:93: 203.92ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:94: 206.84ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:95: 209.04ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:96: 203.88ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:97: 394.91ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:98: 323.38ms +Boxed_Bi_Map_Test.enso_map_with_builder/iteration:99: 203.7ms +Boxed_Bi_Map_Test.enso_map_with_builder average: 225.43ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:0: 95.16ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:1: 39.8ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:2: 41.79ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:3: 36.57ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:4: 52.97ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:5: 55.94ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:6: 56.48ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:7: 48.35ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:8: 49.46ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:9: 47.82ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:10: 27.88ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:11: 33.76ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:12: 47.05ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:13: 37.26ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:14: 42.13ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:15: 50.39ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:16: 48.2ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:17: 36.11ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:18: 45.89ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:19: 52.71ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:20: 52.11ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:21: 46.75ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:22: 42.87ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:23: 52.73ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:24: 52.17ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:25: 50.48ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:26: 42.07ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:27: 30.79ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:28: 52.27ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:29: 45.66ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:30: 46.24ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:31: 50.86ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:32: 40.14ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:33: 33.15ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:34: 40.09ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:35: 54.41ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:36: 51.94ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:37: 38.82ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:38: 44.95ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:39: 40.32ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:40: 42.19ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:41: 36.21ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:42: 42.05ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:43: 47.48ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:44: 483.71ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:45: 202.7ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:46: 54.58ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:47: 50.56ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:48: 53.7ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:49: 75.84ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:50: 63.76ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:51: 69.15ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:52: 43.39ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:53: 49.04ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:54: 61.25ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:55: 48.71ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:56: 40.7ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:57: 61.2ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:58: 64.7ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:59: 53.69ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:60: 55.77ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:61: 56.32ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:62: 67.77ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:63: 57.16ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:64: 54.1ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:65: 65.41ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:66: 58.56ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:67: 61.75ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:68: 62.9ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:69: 72.63ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:70: 68.05ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:71: 58.39ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:72: 53.5ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:73: 69.65ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:74: 68.54ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:75: 69.17ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:76: 69.92ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:77: 61.6ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:78: 51.92ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:79: 53.33ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:80: 69.76ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:81: 489.24ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:82: 56.2ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:83: 54.68ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:84: 60.23ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:85: 68.14ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:86: 53.19ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:87: 58.28ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:88: 71.71ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:89: 81.33ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:90: 69.37ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:91: 59.04ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:92: 54.02ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:93: 48.16ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:94: 56.53ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:95: 55.87ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:96: 49.57ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:97: 43.36ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:98: 47.98ms +Primitive_Total_Aggregate.current_aggregate_implementation/iteration:99: 42.04ms +Primitive_Total_Aggregate.current_aggregate_implementation average: 63.24ms +Primitive_Total_Aggregate.java_loop/iteration:0: 6.64ms +Primitive_Total_Aggregate.java_loop/iteration:1: 1.33ms +Primitive_Total_Aggregate.java_loop/iteration:2: 1.88ms +Primitive_Total_Aggregate.java_loop/iteration:3: 1.91ms +Primitive_Total_Aggregate.java_loop/iteration:4: 1.63ms +Primitive_Total_Aggregate.java_loop/iteration:5: 0.85ms +Primitive_Total_Aggregate.java_loop/iteration:6: 1.28ms +Primitive_Total_Aggregate.java_loop/iteration:7: 1.67ms +Primitive_Total_Aggregate.java_loop/iteration:8: 1.56ms +Primitive_Total_Aggregate.java_loop/iteration:9: 1.56ms +Primitive_Total_Aggregate.java_loop/iteration:10: 1.69ms +Primitive_Total_Aggregate.java_loop/iteration:11: 1ms +Primitive_Total_Aggregate.java_loop/iteration:12: 0.95ms +Primitive_Total_Aggregate.java_loop/iteration:13: 0.89ms +Primitive_Total_Aggregate.java_loop/iteration:14: 1.69ms +Primitive_Total_Aggregate.java_loop/iteration:15: 1.58ms +Primitive_Total_Aggregate.java_loop/iteration:16: 1.15ms +Primitive_Total_Aggregate.java_loop/iteration:17: 0.84ms +Primitive_Total_Aggregate.java_loop/iteration:18: 1.58ms +Primitive_Total_Aggregate.java_loop/iteration:19: 0.88ms +Primitive_Total_Aggregate.java_loop/iteration:20: 1.57ms +Primitive_Total_Aggregate.java_loop/iteration:21: 1.6ms +Primitive_Total_Aggregate.java_loop/iteration:22: 1.66ms +Primitive_Total_Aggregate.java_loop/iteration:23: 1.7ms +Primitive_Total_Aggregate.java_loop/iteration:24: 1.77ms +Primitive_Total_Aggregate.java_loop/iteration:25: 1.08ms +Primitive_Total_Aggregate.java_loop/iteration:26: 1.77ms +Primitive_Total_Aggregate.java_loop/iteration:27: 1.14ms +Primitive_Total_Aggregate.java_loop/iteration:28: 1.66ms +Primitive_Total_Aggregate.java_loop/iteration:29: 1.66ms +Primitive_Total_Aggregate.java_loop/iteration:30: 1.22ms +Primitive_Total_Aggregate.java_loop/iteration:31: 1.07ms +Primitive_Total_Aggregate.java_loop/iteration:32: 1.74ms +Primitive_Total_Aggregate.java_loop/iteration:33: 1.76ms +Primitive_Total_Aggregate.java_loop/iteration:34: 1.86ms +Primitive_Total_Aggregate.java_loop/iteration:35: 1.77ms +Primitive_Total_Aggregate.java_loop/iteration:36: 1.71ms +Primitive_Total_Aggregate.java_loop/iteration:37: 1.65ms +Primitive_Total_Aggregate.java_loop/iteration:38: 1.66ms +Primitive_Total_Aggregate.java_loop/iteration:39: 1.78ms +Primitive_Total_Aggregate.java_loop/iteration:40: 1.7ms +Primitive_Total_Aggregate.java_loop/iteration:41: 1.66ms +Primitive_Total_Aggregate.java_loop/iteration:42: 1.75ms +Primitive_Total_Aggregate.java_loop/iteration:43: 0.94ms +Primitive_Total_Aggregate.java_loop/iteration:44: 1.07ms +Primitive_Total_Aggregate.java_loop/iteration:45: 0.86ms +Primitive_Total_Aggregate.java_loop/iteration:46: 0.94ms +Primitive_Total_Aggregate.java_loop/iteration:47: 1.83ms +Primitive_Total_Aggregate.java_loop/iteration:48: 1.83ms +Primitive_Total_Aggregate.java_loop/iteration:49: 1.74ms +Primitive_Total_Aggregate.java_loop/iteration:50: 1.75ms +Primitive_Total_Aggregate.java_loop/iteration:51: 1.67ms +Primitive_Total_Aggregate.java_loop/iteration:52: 1.67ms +Primitive_Total_Aggregate.java_loop/iteration:53: 1.72ms +Primitive_Total_Aggregate.java_loop/iteration:54: 1.73ms +Primitive_Total_Aggregate.java_loop/iteration:55: 1.74ms +Primitive_Total_Aggregate.java_loop/iteration:56: 1.72ms +Primitive_Total_Aggregate.java_loop/iteration:57: 1.71ms +Primitive_Total_Aggregate.java_loop/iteration:58: 1.77ms +Primitive_Total_Aggregate.java_loop/iteration:59: 1.75ms +Primitive_Total_Aggregate.java_loop/iteration:60: 1.77ms +Primitive_Total_Aggregate.java_loop/iteration:61: 1.79ms +Primitive_Total_Aggregate.java_loop/iteration:62: 1.14ms +Primitive_Total_Aggregate.java_loop/iteration:63: 1.77ms +Primitive_Total_Aggregate.java_loop/iteration:64: 1.76ms +Primitive_Total_Aggregate.java_loop/iteration:65: 1.21ms +Primitive_Total_Aggregate.java_loop/iteration:66: 1.73ms +Primitive_Total_Aggregate.java_loop/iteration:67: 1.7ms +Primitive_Total_Aggregate.java_loop/iteration:68: 1.73ms +Primitive_Total_Aggregate.java_loop/iteration:69: 1.7ms +Primitive_Total_Aggregate.java_loop/iteration:70: 1.78ms +Primitive_Total_Aggregate.java_loop/iteration:71: 0.93ms +Primitive_Total_Aggregate.java_loop/iteration:72: 1.75ms +Primitive_Total_Aggregate.java_loop/iteration:73: 1.3ms +Primitive_Total_Aggregate.java_loop/iteration:74: 1.01ms +Primitive_Total_Aggregate.java_loop/iteration:75: 0.97ms +Primitive_Total_Aggregate.java_loop/iteration:76: 1.7ms +Primitive_Total_Aggregate.java_loop/iteration:77: 1.75ms +Primitive_Total_Aggregate.java_loop/iteration:78: 1.71ms +Primitive_Total_Aggregate.java_loop/iteration:79: 0.94ms +Primitive_Total_Aggregate.java_loop/iteration:80: 0.92ms +Primitive_Total_Aggregate.java_loop/iteration:81: 1.75ms +Primitive_Total_Aggregate.java_loop/iteration:82: 1.75ms +Primitive_Total_Aggregate.java_loop/iteration:83: 1.86ms +Primitive_Total_Aggregate.java_loop/iteration:84: 1.8ms +Primitive_Total_Aggregate.java_loop/iteration:85: 1.7ms +Primitive_Total_Aggregate.java_loop/iteration:86: 1.73ms +Primitive_Total_Aggregate.java_loop/iteration:87: 1.68ms +Primitive_Total_Aggregate.java_loop/iteration:88: 1.69ms +Primitive_Total_Aggregate.java_loop/iteration:89: 1.75ms +Primitive_Total_Aggregate.java_loop/iteration:90: 1.73ms +Primitive_Total_Aggregate.java_loop/iteration:91: 2.08ms +Primitive_Total_Aggregate.java_loop/iteration:92: 1.31ms +Primitive_Total_Aggregate.java_loop/iteration:93: 1.76ms +Primitive_Total_Aggregate.java_loop/iteration:94: 0.87ms +Primitive_Total_Aggregate.java_loop/iteration:95: 0.86ms +Primitive_Total_Aggregate.java_loop/iteration:96: 0.85ms +Primitive_Total_Aggregate.java_loop/iteration:97: 0.83ms +Primitive_Total_Aggregate.java_loop/iteration:98: 0.82ms +Primitive_Total_Aggregate.java_loop/iteration:99: 0.82ms +Primitive_Total_Aggregate.java_loop average: 1.55ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:0: 443.6ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:1: 571.76ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:2: 319.42ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:3: 296.19ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:4: 104.47ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:5: 105.04ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:6: 119.03ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:7: 113.64ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:8: 166.26ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:9: 147.77ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:10: 141.37ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:11: 120.53ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:12: 135.19ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:13: 121.47ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:14: 91.89ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:15: 69.48ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:16: 80.53ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:17: 76.03ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:18: 72.13ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:19: 60.1ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:20: 58.14ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:21: 56.01ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:22: 56.14ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:23: 62.02ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:24: 57.7ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:25: 58.18ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:26: 52.69ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:27: 55.22ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:28: 56.61ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:29: 52.09ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:30: 50.58ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:31: 50.62ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:32: 50.95ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:33: 50.65ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:34: 51.56ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:35: 55.46ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:36: 52.64ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:37: 52.38ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:38: 50.13ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:39: 49.71ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:40: 50.17ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:41: 51.1ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:42: 90.16ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:43: 84.59ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:44: 63.66ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:45: 59.1ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:46: 60.53ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:47: 56.02ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:48: 52.75ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:49: 52.79ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:50: 51.94ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:51: 51.07ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:52: 52.39ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:53: 57.04ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:54: 53.66ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:55: 53.86ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:56: 55.82ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:57: 57.05ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:58: 53.84ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:59: 52.71ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:60: 51.77ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:61: 51.36ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:62: 54.23ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:63: 51.88ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:64: 52.68ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:65: 51.49ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:66: 50.04ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:67: 52.42ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:68: 52.18ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:69: 87.25ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:70: 101.12ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:71: 64.64ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:72: 60.79ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:73: 56.34ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:74: 56.82ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:75: 54.18ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:76: 54.27ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:77: 55.41ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:78: 51.29ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:79: 51.7ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:80: 51.46ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:81: 55.56ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:82: 57.51ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:83: 51.51ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:84: 50.84ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:85: 51.02ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:86: 49.72ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:87: 52.17ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:88: 52.76ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:89: 53.28ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:90: 51.11ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:91: 51.59ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:92: 50.15ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:93: 50.87ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:94: 63ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:95: 87.83ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:96: 70.02ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:97: 68.03ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:98: 58.21ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy/iteration:99: 55.34ms +Primitive_Total_Aggregate.enso_aggregate_vector_proxy average: 78.89ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:0: 399.11ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:1: 394.72ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:2: 137.55ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:3: 142.94ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:4: 136.55ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:5: 150.8ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:6: 186.31ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:7: 124.45ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:8: 133.07ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:9: 121.46ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:10: 131.53ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:11: 101.93ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:12: 90.27ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:13: 103.71ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:14: 141.16ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:15: 88.93ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:16: 94.47ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:17: 69.69ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:18: 66.99ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:19: 66.62ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:20: 65.4ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:21: 64.79ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:22: 63.74ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:23: 68.15ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:24: 79.38ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:25: 107.81ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:26: 74.09ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:27: 65.82ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:28: 65.99ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:29: 65.72ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:30: 63.88ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:31: 64.87ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:32: 66.66ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:33: 63.84ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:34: 63.89ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:35: 70.16ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:36: 103.92ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:37: 106.02ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:38: 79.14ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:39: 84.25ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:40: 69.03ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:41: 66.61ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:42: 69.51ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:43: 69.62ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:44: 65.98ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:45: 71.73ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:46: 96.41ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:47: 64.25ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:48: 66.64ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:49: 85.97ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:50: 87.86ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:51: 73.71ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:52: 68.4ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:53: 61.47ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:54: 62.22ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:55: 62.83ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:56: 62.43ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:57: 63.01ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:58: 63.28ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:59: 63.26ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:60: 103.93ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:61: 133.87ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:62: 77.19ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:63: 70.36ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:64: 69.92ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:65: 68.28ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:66: 67.8ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:67: 68.15ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:68: 65.95ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:69: 66.43ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:70: 68.18ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:71: 71.49ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:72: 95.14ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:73: 71.04ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:74: 72.46ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:75: 64.45ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:76: 72.48ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:77: 65.75ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:78: 65.88ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:79: 64.87ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:80: 65.08ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:81: 65.09ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:82: 95.87ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:83: 111.71ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:84: 80.55ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:85: 72.59ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:86: 76.34ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:87: 77.19ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:88: 65.98ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:89: 66.11ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:90: 65.86ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:91: 66.3ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:92: 79.78ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:93: 83.41ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:94: 63.94ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:95: 68.9ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:96: 63.79ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:97: 64.93ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:98: 63.48ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item/iteration:99: 64.07ms +Primitive_Total_Aggregate.enso_aggregate_storage_get_item average: 87.29ms +Boxed_Sum_Months.java_loop/iteration:0: 3.98ms +Boxed_Sum_Months.java_loop/iteration:1: 6.38ms +Boxed_Sum_Months.java_loop/iteration:2: 2.28ms +Boxed_Sum_Months.java_loop/iteration:3: 2.26ms +Boxed_Sum_Months.java_loop/iteration:4: 2.18ms +Boxed_Sum_Months.java_loop/iteration:5: 2.22ms +Boxed_Sum_Months.java_loop/iteration:6: 2.11ms +Boxed_Sum_Months.java_loop/iteration:7: 2.19ms +Boxed_Sum_Months.java_loop/iteration:8: 2.44ms +Boxed_Sum_Months.java_loop/iteration:9: 2.45ms +Boxed_Sum_Months.java_loop/iteration:10: 2.09ms +Boxed_Sum_Months.java_loop/iteration:11: 2.05ms +Boxed_Sum_Months.java_loop/iteration:12: 1.82ms +Boxed_Sum_Months.java_loop/iteration:13: 1.76ms +Boxed_Sum_Months.java_loop/iteration:14: 2.56ms +Boxed_Sum_Months.java_loop/iteration:15: 2.51ms +Boxed_Sum_Months.java_loop/iteration:16: 1.93ms +Boxed_Sum_Months.java_loop/iteration:17: 1.93ms +Boxed_Sum_Months.java_loop/iteration:18: 1.82ms +Boxed_Sum_Months.java_loop/iteration:19: 1.55ms +Boxed_Sum_Months.java_loop/iteration:20: 1.95ms +Boxed_Sum_Months.java_loop/iteration:21: 2.76ms +Boxed_Sum_Months.java_loop/iteration:22: 2.12ms +Boxed_Sum_Months.java_loop/iteration:23: 2.46ms +Boxed_Sum_Months.java_loop/iteration:24: 2.26ms +Boxed_Sum_Months.java_loop/iteration:25: 2.19ms +Boxed_Sum_Months.java_loop/iteration:26: 2.21ms +Boxed_Sum_Months.java_loop/iteration:27: 2.35ms +Boxed_Sum_Months.java_loop/iteration:28: 2.99ms +Boxed_Sum_Months.java_loop/iteration:29: 2.54ms +Boxed_Sum_Months.java_loop/iteration:30: 2.13ms +Boxed_Sum_Months.java_loop/iteration:31: 2.13ms +Boxed_Sum_Months.java_loop/iteration:32: 2.36ms +Boxed_Sum_Months.java_loop/iteration:33: 2.84ms +Boxed_Sum_Months.java_loop/iteration:34: 1.86ms +Boxed_Sum_Months.java_loop/iteration:35: 2.11ms +Boxed_Sum_Months.java_loop/iteration:36: 2.15ms +Boxed_Sum_Months.java_loop/iteration:37: 1.79ms +Boxed_Sum_Months.java_loop/iteration:38: 1.89ms +Boxed_Sum_Months.java_loop/iteration:39: 2.39ms +Boxed_Sum_Months.java_loop/iteration:40: 3.24ms +Boxed_Sum_Months.java_loop/iteration:41: 2.22ms +Boxed_Sum_Months.java_loop/iteration:42: 2.39ms +Boxed_Sum_Months.java_loop/iteration:43: 1.98ms +Boxed_Sum_Months.java_loop/iteration:44: 2.01ms +Boxed_Sum_Months.java_loop/iteration:45: 2ms +Boxed_Sum_Months.java_loop/iteration:46: 2.59ms +Boxed_Sum_Months.java_loop/iteration:47: 1.99ms +Boxed_Sum_Months.java_loop/iteration:48: 1.83ms +Boxed_Sum_Months.java_loop/iteration:49: 1.75ms +Boxed_Sum_Months.java_loop/iteration:50: 2.33ms +Boxed_Sum_Months.java_loop/iteration:51: 1.92ms +Boxed_Sum_Months.java_loop/iteration:52: 2.1ms +Boxed_Sum_Months.java_loop/iteration:53: 2.38ms +Boxed_Sum_Months.java_loop/iteration:54: 1.95ms +Boxed_Sum_Months.java_loop/iteration:55: 1.67ms +Boxed_Sum_Months.java_loop/iteration:56: 1.68ms +Boxed_Sum_Months.java_loop/iteration:57: 1.99ms +Boxed_Sum_Months.java_loop/iteration:58: 1.76ms +Boxed_Sum_Months.java_loop/iteration:59: 1.85ms +Boxed_Sum_Months.java_loop/iteration:60: 3.36ms +Boxed_Sum_Months.java_loop/iteration:61: 1.76ms +Boxed_Sum_Months.java_loop/iteration:62: 1.74ms +Boxed_Sum_Months.java_loop/iteration:63: 1.63ms +Boxed_Sum_Months.java_loop/iteration:64: 2.01ms +Boxed_Sum_Months.java_loop/iteration:65: 1.93ms +Boxed_Sum_Months.java_loop/iteration:66: 1.95ms +Boxed_Sum_Months.java_loop/iteration:67: 2.09ms +Boxed_Sum_Months.java_loop/iteration:68: 2.14ms +Boxed_Sum_Months.java_loop/iteration:69: 1.97ms +Boxed_Sum_Months.java_loop/iteration:70: 1.74ms +Boxed_Sum_Months.java_loop/iteration:71: 1.74ms +Boxed_Sum_Months.java_loop/iteration:72: 1.97ms +Boxed_Sum_Months.java_loop/iteration:73: 1.87ms +Boxed_Sum_Months.java_loop/iteration:74: 1.97ms +Boxed_Sum_Months.java_loop/iteration:75: 2.2ms +Boxed_Sum_Months.java_loop/iteration:76: 1.99ms +Boxed_Sum_Months.java_loop/iteration:77: 1.8ms +Boxed_Sum_Months.java_loop/iteration:78: 1.92ms +Boxed_Sum_Months.java_loop/iteration:79: 1.54ms +Boxed_Sum_Months.java_loop/iteration:80: 2.25ms +Boxed_Sum_Months.java_loop/iteration:81: 1.84ms +Boxed_Sum_Months.java_loop/iteration:82: 2.34ms +Boxed_Sum_Months.java_loop/iteration:83: 2.07ms +Boxed_Sum_Months.java_loop/iteration:84: 1.87ms +Boxed_Sum_Months.java_loop/iteration:85: 1.73ms +Boxed_Sum_Months.java_loop/iteration:86: 1.72ms +Boxed_Sum_Months.java_loop/iteration:87: 2.03ms +Boxed_Sum_Months.java_loop/iteration:88: 1.94ms +Boxed_Sum_Months.java_loop/iteration:89: 2.65ms +Boxed_Sum_Months.java_loop/iteration:90: 1.98ms +Boxed_Sum_Months.java_loop/iteration:91: 2.05ms +Boxed_Sum_Months.java_loop/iteration:92: 1.73ms +Boxed_Sum_Months.java_loop/iteration:93: 1.8ms +Boxed_Sum_Months.java_loop/iteration:94: 1.89ms +Boxed_Sum_Months.java_loop/iteration:95: 2.5ms +Boxed_Sum_Months.java_loop/iteration:96: 2.81ms +Boxed_Sum_Months.java_loop/iteration:97: 1.97ms +Boxed_Sum_Months.java_loop/iteration:98: 2.03ms +Boxed_Sum_Months.java_loop/iteration:99: 1.91ms +Boxed_Sum_Months.java_loop average: 2.16ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:0: 294.34ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:1: 308.44ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:2: 85.29ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:3: 163.55ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:4: 158.7ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:5: 216.68ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:6: 151.95ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:7: 113.74ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:8: 144.55ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:9: 132.48ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:10: 131.13ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:11: 109.14ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:12: 84.45ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:13: 77.29ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:14: 123.45ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:15: 100.02ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:16: 76.71ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:17: 72.44ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:18: 71.06ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:19: 67.29ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:20: 65.51ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:21: 65.28ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:22: 62.68ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:23: 75.53ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:24: 65.8ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:25: 69.88ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:26: 70.7ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:27: 65.54ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:28: 65.56ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:29: 68.27ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:30: 63.04ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:31: 62.52ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:32: 67.5ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:33: 65.15ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:34: 80.76ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:35: 81.35ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:36: 111.31ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:37: 96.22ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:38: 76.24ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:39: 70.71ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:40: 68.05ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:41: 67.21ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:42: 72.17ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:43: 65.26ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:44: 66.08ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:45: 69.31ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:46: 72.78ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:47: 79.95ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:48: 62.49ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:49: 62.71ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:50: 62.84ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:51: 64.47ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:52: 62.22ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:53: 63.31ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:54: 70.11ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:55: 122.1ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:56: 120.93ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:57: 71.57ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:58: 72.86ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:59: 67.84ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:60: 67.09ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:61: 64.76ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:62: 67.07ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:63: 66.88ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:64: 72.12ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:65: 63.58ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:66: 64.23ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:67: 63.03ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:68: 64.2ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:69: 63.52ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:70: 63.35ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:71: 65.77ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:72: 62.6ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:73: 67.42ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:74: 107.33ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:75: 103.42ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:76: 76.44ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:77: 70.27ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:78: 67.54ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:79: 65.56ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:80: 65.32ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:81: 67.02ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:82: 65.4ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:83: 71.75ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:84: 65.43ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:85: 64.56ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:86: 65.89ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:87: 66.95ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:88: 65.78ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:89: 64.39ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:90: 63.87ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:91: 63.78ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:92: 67.66ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:93: 106.51ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:94: 86.05ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:95: 78.92ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:96: 77.04ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:97: 70.42ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:98: 69.06ms +Boxed_Sum_Months.enso_aggregate_vector_proxy/iteration:99: 75.38ms +Boxed_Sum_Months.enso_aggregate_vector_proxy average: 84.24ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:0: 290.46ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:1: 307.94ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:2: 93.29ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:3: 106.73ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:4: 119.96ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:5: 114.79ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:6: 131.12ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:7: 131.69ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:8: 104.33ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:9: 106.45ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:10: 126.22ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:11: 115.63ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:12: 117.06ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:13: 83.22ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:14: 78.49ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:15: 69.27ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:16: 67.04ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:17: 66.31ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:18: 65.13ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:19: 63.83ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:20: 57.34ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:21: 55.63ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:22: 55.41ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:23: 62.51ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:24: 60.37ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:25: 62.82ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:26: 82.94ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:27: 96.83ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:28: 78.83ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:29: 65.84ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:30: 61.15ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:31: 70.86ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:32: 68.13ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:33: 65.05ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:34: 62.2ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:35: 56.86ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:36: 55.74ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:37: 55.32ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:38: 54.81ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:39: 57.1ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:40: 53.46ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:41: 52.76ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:42: 69.6ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:43: 90.76ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:44: 72.87ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:45: 72.07ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:46: 67.22ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:47: 61.83ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:48: 60.13ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:49: 57.98ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:50: 67.31ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:51: 59.56ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:52: 54.75ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:53: 56.21ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:54: 54.47ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:55: 54.7ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:56: 53.27ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:57: 52.63ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:58: 85.22ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:59: 106.67ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:60: 96.01ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:61: 63.21ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:62: 57.67ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:63: 59.51ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:64: 56.68ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:65: 57.81ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:66: 57.35ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:67: 53.55ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:68: 59.02ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:69: 58.82ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:70: 54.89ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:71: 53.2ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:72: 52.35ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:73: 52.19ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:74: 51.98ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:75: 51.83ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:76: 51.45ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:77: 75.28ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:78: 93.51ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:79: 75.74ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:80: 67.13ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:81: 61.53ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:82: 58.98ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:83: 56.77ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:84: 60.95ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:85: 61.13ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:86: 57.28ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:87: 53.93ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:88: 54.26ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:89: 55.82ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:90: 53.68ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:91: 53.23ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:92: 54.82ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:93: 77.19ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:94: 113.28ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:95: 74.98ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:96: 64.9ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:97: 62.37ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:98: 61.87ms +Boxed_Sum_Months.enso_aggregate_storage_get_item/iteration:99: 56.77ms +Boxed_Sum_Months.enso_aggregate_storage_get_item average: 74.41ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:0: 601.51ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:1: 762.52ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:2: 537.73ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:3: 609.02ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:4: 603.7ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:5: 522.28ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:6: 558.13ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:7: 545.8ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:8: 598.85ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:9: 501.84ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:10: 597.77ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:11: 515.65ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:12: 535.54ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:13: 517.86ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:14: 583.7ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:15: 536.66ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:16: 587.17ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:17: 527.21ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:18: 583.18ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:19: 620.3ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:20: 617.84ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:21: 720.44ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:22: 570.13ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:23: 437.57ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:24: 568.95ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:25: 465.5ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:26: 548.51ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:27: 436.74ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:28: 511.14ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:29: 423.38ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:30: 535.62ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:31: 768.66ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:32: 409.94ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:33: 559.48ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:34: 480.08ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:35: 546.31ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:36: 443.89ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:37: 527.26ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:38: 492.5ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:39: 525.41ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:40: 447.41ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:41: 514.22ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:42: 430.23ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:43: 517.85ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:44: 485.74ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:45: 502.35ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:46: 429.61ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:47: 447.23ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:48: 522.83ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:49: 435.57ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:50: 780.3ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:51: 440.76ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:52: 443.5ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:53: 395.59ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:54: 472.81ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:55: 476.48ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:56: 502.56ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:57: 496.6ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:58: 508.04ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:59: 505.51ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:60: 461.63ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:61: 545.88ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:62: 520.63ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:63: 405.18ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:64: 540.28ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:65: 669.54ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:66: 395.13ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:67: 515.11ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:68: 517.16ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:69: 411.67ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:70: 533.35ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:71: 398.24ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:72: 633.6ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:73: 500.18ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:74: 421.11ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:75: 573.07ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:76: 405.97ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:77: 571.01ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:78: 577.54ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:79: 465.64ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:80: 557.95ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:81: 436.83ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:82: 548.98ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:83: 411.83ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:84: 568.43ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:85: 383.26ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:86: 655.74ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:87: 375.46ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:88: 585.44ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:89: 497.79ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:90: 474.98ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:91: 493.81ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:92: 471.16ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:93: 656.1ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:94: 402.47ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:95: 535.8ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:96: 461.62ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:97: 583.29ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:98: 460.71ms +Boxed_Total_Aggregate.current_aggregate_implementation/iteration:99: 572.31ms +Boxed_Total_Aggregate.current_aggregate_implementation average: 519.87ms +Boxed_Total_Aggregate.java_loop/iteration:0: 421.27ms +Boxed_Total_Aggregate.java_loop/iteration:1: 571.86ms +Boxed_Total_Aggregate.java_loop/iteration:2: 391.17ms +Boxed_Total_Aggregate.java_loop/iteration:3: 482.99ms +Boxed_Total_Aggregate.java_loop/iteration:4: 377.7ms +Boxed_Total_Aggregate.java_loop/iteration:5: 507.3ms +Boxed_Total_Aggregate.java_loop/iteration:6: 390.41ms +Boxed_Total_Aggregate.java_loop/iteration:7: 468.02ms +Boxed_Total_Aggregate.java_loop/iteration:8: 411.05ms +Boxed_Total_Aggregate.java_loop/iteration:9: 486.37ms +Boxed_Total_Aggregate.java_loop/iteration:10: 380.02ms +Boxed_Total_Aggregate.java_loop/iteration:11: 489.39ms +Boxed_Total_Aggregate.java_loop/iteration:12: 400.79ms +Boxed_Total_Aggregate.java_loop/iteration:13: 486.89ms +Boxed_Total_Aggregate.java_loop/iteration:14: 443.32ms +Boxed_Total_Aggregate.java_loop/iteration:15: 356.39ms +Boxed_Total_Aggregate.java_loop/iteration:16: 496.54ms +Boxed_Total_Aggregate.java_loop/iteration:17: 358.15ms +Boxed_Total_Aggregate.java_loop/iteration:18: 521.43ms +Boxed_Total_Aggregate.java_loop/iteration:19: 375.61ms +Boxed_Total_Aggregate.java_loop/iteration:20: 497.49ms +Boxed_Total_Aggregate.java_loop/iteration:21: 366.02ms +Boxed_Total_Aggregate.java_loop/iteration:22: 509.8ms +Boxed_Total_Aggregate.java_loop/iteration:23: 438.94ms +Boxed_Total_Aggregate.java_loop/iteration:24: 469.31ms +Boxed_Total_Aggregate.java_loop/iteration:25: 402.12ms +Boxed_Total_Aggregate.java_loop/iteration:26: 440.07ms +Boxed_Total_Aggregate.java_loop/iteration:27: 397.39ms +Boxed_Total_Aggregate.java_loop/iteration:28: 366.97ms +Boxed_Total_Aggregate.java_loop/iteration:29: 437.29ms +Boxed_Total_Aggregate.java_loop/iteration:30: 365.94ms +Boxed_Total_Aggregate.java_loop/iteration:31: 385.63ms +Boxed_Total_Aggregate.java_loop/iteration:32: 373.69ms +Boxed_Total_Aggregate.java_loop/iteration:33: 365.96ms +Boxed_Total_Aggregate.java_loop/iteration:34: 353.93ms +Boxed_Total_Aggregate.java_loop/iteration:35: 385.74ms +Boxed_Total_Aggregate.java_loop/iteration:36: 353.64ms +Boxed_Total_Aggregate.java_loop/iteration:37: 366.89ms +Boxed_Total_Aggregate.java_loop/iteration:38: 373.44ms +Boxed_Total_Aggregate.java_loop/iteration:39: 360.84ms +Boxed_Total_Aggregate.java_loop/iteration:40: 365.88ms +Boxed_Total_Aggregate.java_loop/iteration:41: 361.91ms +Boxed_Total_Aggregate.java_loop/iteration:42: 362.04ms +Boxed_Total_Aggregate.java_loop/iteration:43: 372.46ms +Boxed_Total_Aggregate.java_loop/iteration:44: 370.58ms +Boxed_Total_Aggregate.java_loop/iteration:45: 368.99ms +Boxed_Total_Aggregate.java_loop/iteration:46: 352.09ms +Boxed_Total_Aggregate.java_loop/iteration:47: 379.04ms +Boxed_Total_Aggregate.java_loop/iteration:48: 354.34ms +Boxed_Total_Aggregate.java_loop/iteration:49: 366.92ms +Boxed_Total_Aggregate.java_loop/iteration:50: 379.57ms +Boxed_Total_Aggregate.java_loop/iteration:51: 360.68ms +Boxed_Total_Aggregate.java_loop/iteration:52: 364.25ms +Boxed_Total_Aggregate.java_loop/iteration:53: 368.75ms +Boxed_Total_Aggregate.java_loop/iteration:54: 391.87ms +Boxed_Total_Aggregate.java_loop/iteration:55: 367.15ms +Boxed_Total_Aggregate.java_loop/iteration:56: 368.52ms +Boxed_Total_Aggregate.java_loop/iteration:57: 362.96ms +Boxed_Total_Aggregate.java_loop/iteration:58: 370.09ms +Boxed_Total_Aggregate.java_loop/iteration:59: 354.47ms +Boxed_Total_Aggregate.java_loop/iteration:60: 369.95ms +Boxed_Total_Aggregate.java_loop/iteration:61: 340.34ms +Boxed_Total_Aggregate.java_loop/iteration:62: 373.27ms +Boxed_Total_Aggregate.java_loop/iteration:63: 381.26ms +Boxed_Total_Aggregate.java_loop/iteration:64: 375.35ms +Boxed_Total_Aggregate.java_loop/iteration:65: 359.59ms +Boxed_Total_Aggregate.java_loop/iteration:66: 374.5ms +Boxed_Total_Aggregate.java_loop/iteration:67: 353.46ms +Boxed_Total_Aggregate.java_loop/iteration:68: 377.09ms +Boxed_Total_Aggregate.java_loop/iteration:69: 370.27ms +Boxed_Total_Aggregate.java_loop/iteration:70: 371.52ms +Boxed_Total_Aggregate.java_loop/iteration:71: 370.94ms +Boxed_Total_Aggregate.java_loop/iteration:72: 366.72ms +Boxed_Total_Aggregate.java_loop/iteration:73: 395.84ms +Boxed_Total_Aggregate.java_loop/iteration:74: 362.19ms +Boxed_Total_Aggregate.java_loop/iteration:75: 360.7ms +Boxed_Total_Aggregate.java_loop/iteration:76: 375.91ms +Boxed_Total_Aggregate.java_loop/iteration:77: 369.41ms +Boxed_Total_Aggregate.java_loop/iteration:78: 360.6ms +Boxed_Total_Aggregate.java_loop/iteration:79: 364.05ms +Boxed_Total_Aggregate.java_loop/iteration:80: 354.6ms +Boxed_Total_Aggregate.java_loop/iteration:81: 377.79ms +Boxed_Total_Aggregate.java_loop/iteration:82: 358.15ms +Boxed_Total_Aggregate.java_loop/iteration:83: 361.34ms +Boxed_Total_Aggregate.java_loop/iteration:84: 401.57ms +Boxed_Total_Aggregate.java_loop/iteration:85: 375.13ms +Boxed_Total_Aggregate.java_loop/iteration:86: 396.65ms +Boxed_Total_Aggregate.java_loop/iteration:87: 383.74ms +Boxed_Total_Aggregate.java_loop/iteration:88: 360.97ms +Boxed_Total_Aggregate.java_loop/iteration:89: 371.01ms +Boxed_Total_Aggregate.java_loop/iteration:90: 373.38ms +Boxed_Total_Aggregate.java_loop/iteration:91: 377.56ms +Boxed_Total_Aggregate.java_loop/iteration:92: 397.54ms +Boxed_Total_Aggregate.java_loop/iteration:93: 364.55ms +Boxed_Total_Aggregate.java_loop/iteration:94: 386.11ms +Boxed_Total_Aggregate.java_loop/iteration:95: 370.3ms +Boxed_Total_Aggregate.java_loop/iteration:96: 366.08ms +Boxed_Total_Aggregate.java_loop/iteration:97: 363.63ms +Boxed_Total_Aggregate.java_loop/iteration:98: 372.13ms +Boxed_Total_Aggregate.java_loop/iteration:99: 380.54ms +Boxed_Total_Aggregate.java_loop average: 390.36ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:0: 831.24ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:1: 644.23ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:2: 572.5ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:3: 739.44ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:4: 622.8ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:5: 445.12ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:6: 418.53ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:7: 421.58ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:8: 401.92ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:9: 409.1ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:10: 393.13ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:11: 414.18ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:12: 416.5ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:13: 405.33ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:14: 426.37ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:15: 405.8ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:16: 399ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:17: 414.04ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:18: 416.09ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:19: 416.47ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:20: 394.03ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:21: 419.4ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:22: 402.05ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:23: 421.98ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:24: 423.8ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:25: 412.44ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:26: 442.74ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:27: 395.72ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:28: 417.84ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:29: 411.02ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:30: 411.9ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:31: 401.15ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:32: 393.43ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:33: 428.05ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:34: 404.81ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:35: 402.84ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:36: 420.82ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:37: 401.69ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:38: 430.09ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:39: 407.64ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:40: 390.29ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:41: 422.65ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:42: 405ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:43: 428.42ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:44: 396.41ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:45: 418.1ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:46: 399.28ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:47: 429.68ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:48: 406.94ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:49: 423.54ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:50: 451.93ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:51: 406.97ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:52: 400.04ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:53: 407.92ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:54: 405.08ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:55: 410.04ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:56: 404.08ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:57: 406.26ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:58: 412.88ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:59: 403.39ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:60: 418.3ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:61: 421.68ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:62: 426.46ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:63: 415.69ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:64: 431.3ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:65: 417.1ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:66: 390.11ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:67: 434.73ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:68: 418.33ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:69: 481.34ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:70: 495.31ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:71: 525.36ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:72: 524.57ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:73: 535.16ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:74: 503.83ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:75: 468.93ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:76: 431.96ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:77: 420.82ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:78: 394.71ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:79: 393.39ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:80: 443.3ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:81: 394.44ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:82: 397.41ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:83: 429.67ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:84: 408.24ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:85: 402.55ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:86: 397.41ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:87: 443.19ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:88: 398.5ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:89: 423.53ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:90: 426.09ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:91: 400.67ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:92: 411.39ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:93: 395.47ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:94: 438.74ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:95: 408.7ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:96: 408.76ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:97: 396ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:98: 428.54ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy/iteration:99: 409.73ms +Boxed_Total_Aggregate.enso_aggregate_vector_proxy average: 432.97ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:0: 893.78ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:1: 732.3ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:2: 677.5ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:3: 802.24ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:4: 573.38ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:5: 477.65ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:6: 411.25ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:7: 439.21ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:8: 429.09ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:9: 411.73ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:10: 433.73ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:11: 421.91ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:12: 450.62ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:13: 430.65ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:14: 424.23ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:15: 423.9ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:16: 443.87ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:17: 452.66ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:18: 424.58ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:19: 433.38ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:20: 431.75ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:21: 436.91ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:22: 433.42ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:23: 442.17ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:24: 468.4ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:25: 446.68ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:26: 446.03ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:27: 430.01ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:28: 426.17ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:29: 422.37ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:30: 460.3ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:31: 441.31ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:32: 447.85ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:33: 471.57ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:34: 422.35ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:35: 422.08ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:36: 453.23ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:37: 415.91ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:38: 424.56ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:39: 446.83ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:40: 431.1ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:41: 452.12ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:42: 427.2ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:43: 414.68ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:44: 454.93ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:45: 426.86ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:46: 423.62ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:47: 428.25ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:48: 426.06ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:49: 466.84ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:50: 444.61ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:51: 433.73ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:52: 456.57ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:53: 426.13ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:54: 423.33ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:55: 442.87ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:56: 458ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:57: 420.46ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:58: 475.11ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:59: 436.04ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:60: 437.78ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:61: 427.3ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:62: 458.56ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:63: 437.64ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:64: 413.3ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:65: 430.42ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:66: 423.17ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:67: 434.25ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:68: 429.42ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:69: 435.24ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:70: 438.69ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:71: 428.28ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:72: 455.68ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:73: 436.81ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:74: 460.03ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:75: 449.27ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:76: 427.32ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:77: 448.52ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:78: 457.09ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:79: 447.62ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:80: 430.18ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:81: 469.4ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:82: 420.6ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:83: 457.28ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:84: 418.06ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:85: 433.54ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:86: 439.94ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:87: 464.35ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:88: 443.68ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:89: 419.09ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:90: 444.07ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:91: 448.64ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:92: 440.77ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:93: 439.5ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:94: 466.84ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:95: 425.42ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:96: 429.26ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:97: 468.13ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:98: 423.73ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item/iteration:99: 443.76ms +Boxed_Total_Aggregate.enso_aggregate_storage_get_item average: 453.49ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:0: 187.31ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:1: 211.25ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:2: 545.35ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:3: 305.48ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:4: 276.83ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:5: 289.3ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:6: 240.69ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:7: 204.85ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:8: 278.28ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:9: 343.4ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:10: 237.45ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:11: 192.56ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:12: 198.27ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:13: 347.26ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:14: 298.97ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:15: 210.84ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:16: 172.82ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:17: 192.46ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:18: 274.73ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:19: 225.37ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:20: 178.01ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:21: 221.53ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:22: 370.21ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:23: 227.09ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:24: 293.16ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:25: 238.47ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:26: 162.51ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:27: 150.28ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:28: 183.36ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:29: 310.85ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:30: 259.36ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:31: 166.96ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:32: 144.16ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:33: 144.91ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:34: 233.99ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:35: 240.63ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:36: 199.48ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:37: 147.98ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:38: 144.67ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:39: 291.28ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:40: 183.56ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:41: 157.52ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:42: 150.62ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:43: 171.87ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:44: 256.81ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:45: 182.36ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:46: 155.88ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:47: 198.28ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:48: 295.56ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:49: 169.15ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:50: 196.47ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:51: 247.69ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:52: 183.29ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:53: 156.47ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:54: 145.81ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:55: 299.86ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:56: 188.03ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:57: 159.96ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:58: 144.17ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:59: 183.98ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:60: 280.55ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:61: 166.83ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:62: 149.53ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:63: 281.01ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:64: 178.9ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:65: 152.26ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:66: 144.36ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:67: 135.74ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:68: 309.22ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:69: 189.65ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:70: 156.14ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:71: 199.34ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:72: 272.57ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:73: 188.82ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:74: 191.73ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:75: 224.58ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:76: 166.52ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:77: 208.57ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:78: 262.15ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:79: 173.34ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:80: 153.95ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:81: 255.18ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:82: 197.97ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:83: 153.24ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:84: 149.33ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:85: 285.57ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:86: 221.69ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:87: 170.54ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:88: 150.33ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:89: 136.74ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:90: 314.9ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:91: 184.35ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:92: 145.69ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:93: 187.13ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:94: 317.85ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:95: 238.15ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:96: 202.46ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:97: 252.71ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:98: 168.48ms +Primitive_Enso_Callback_Test.current_implementation_as_map/iteration:99: 151.77ms +Primitive_Enso_Callback_Test.current_implementation_as_map average: 214.4ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:0: 1.84ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:1: 1.72ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:2: 1.69ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:3: 1.55ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:4: 1.41ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:5: 1.51ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:6: 1.53ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:7: 1.43ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:8: 1.51ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:9: 1.39ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:10: 1.51ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:11: 2.52ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:12: 2.16ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:13: 1.66ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:14: 1.49ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:15: 1.44ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:16: 1.36ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:17: 1.38ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:18: 1.31ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:19: 2.47ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:20: 1.87ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:21: 1.84ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:22: 1.84ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:23: 3.46ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:24: 1.88ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:25: 3.57ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:26: 2.44ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:27: 2.54ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:28: 2.61ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:29: 2.26ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:30: 2.25ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:31: 2.95ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:32: 2.35ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:33: 2.52ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:34: 2.47ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:35: 2.39ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:36: 2.4ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:37: 2.23ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:38: 2.36ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:39: 2.46ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:40: 2.44ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:41: 1.86ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:42: 2.47ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:43: 2.51ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:44: 2.56ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:45: 2.5ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:46: 2.63ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:47: 2.46ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:48: 2.66ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:49: 1.91ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:50: 2.38ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:51: 2.5ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:52: 2.62ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:53: 2.42ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:54: 2.41ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:55: 2.35ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:56: 1.94ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:57: 2.04ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:58: 2.14ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:59: 1.83ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:60: 2.32ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:61: 2.2ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:62: 1.96ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:63: 1.86ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:64: 2.25ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:65: 2.06ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:66: 1.58ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:67: 2.13ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:68: 2.86ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:69: 1.79ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:70: 1.77ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:71: 1.79ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:72: 1.92ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:73: 2.35ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:74: 19.82ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:75: 1.85ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:76: 1.78ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:77: 1.76ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:78: 1.73ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:79: 1.67ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:80: 1.79ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:81: 1.64ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:82: 2.45ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:83: 1.79ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:84: 1.93ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:85: 2.64ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:86: 2.63ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:87: 2.72ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:88: 2.88ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:89: 2.8ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:90: 2.62ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:91: 2.52ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:92: 2.59ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:93: 2.73ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:94: 2.77ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:95: 2.67ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:96: 2.57ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:97: 2.56ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:98: 2.8ms +Primitive_Enso_Callback_Test.java_vectorized/iteration:99: 2.27ms +Primitive_Enso_Callback_Test.java_vectorized average: 2.35ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:0: 80.76ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:1: 48.44ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:2: 46.39ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:3: 90.83ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:4: 44.81ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:5: 32.29ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:6: 23.6ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:7: 26.43ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:8: 23.9ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:9: 23.34ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:10: 21.36ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:11: 23.53ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:12: 21.15ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:13: 20.29ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:14: 20.69ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:15: 20.39ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:16: 19.84ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:17: 19.35ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:18: 24.19ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:19: 25.43ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:20: 36.37ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:21: 38.9ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:22: 30.48ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:23: 46.59ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:24: 47.48ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:25: 42.88ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:26: 35.22ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:27: 24.5ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:28: 23.67ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:29: 22.59ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:30: 22.72ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:31: 21.89ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:32: 21.3ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:33: 21.68ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:34: 26.52ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:35: 28.01ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:36: 24.58ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:37: 24.83ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:38: 39.45ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:39: 29.68ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:40: 51.64ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:41: 32.76ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:42: 25.91ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:43: 26.58ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:44: 23.16ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:45: 22.86ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:46: 22.73ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:47: 21.64ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:48: 22ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:49: 21.13ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:50: 25.78ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:51: 26.29ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:52: 30.31ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:53: 24.98ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:54: 40.97ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:55: 75.92ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:56: 39.89ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:57: 28.76ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:58: 27.25ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:59: 21.9ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:60: 28.56ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:61: 21.85ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:62: 21.75ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:63: 21.17ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:64: 21.79ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:65: 20.8ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:66: 20.54ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:67: 19.89ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:68: 21.04ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:69: 19.55ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:70: 21.69ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:71: 23.31ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:72: 24.71ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:73: 40.38ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:74: 33.92ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:75: 48.8ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:76: 34.55ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:77: 31.84ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:78: 22.91ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:79: 22.35ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:80: 21.88ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:81: 22.29ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:82: 20.78ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:83: 22.12ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:84: 20.54ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:85: 20.84ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:86: 23.17ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:87: 19.86ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:88: 31.44ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:89: 25.2ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:90: 24.17ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:91: 24.8ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:92: 28.74ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:93: 29.58ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:94: 36.9ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:95: 31.91ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:96: 29.18ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:97: 24.52ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:98: 23.59ms +Primitive_Enso_Callback_Test.java_roundtrip/iteration:99: 22.8ms +Primitive_Enso_Callback_Test.java_roundtrip average: 29.05ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:0: 136.11ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:1: 148.55ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:2: 208.63ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:3: 162.32ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:4: 180.08ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:5: 166.75ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:6: 165.4ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:7: 170.61ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:8: 180.52ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:9: 158.64ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:10: 165.48ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:11: 240.89ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:12: 236.97ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:13: 127.59ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:14: 118.77ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:15: 124.59ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:16: 112.87ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:17: 109.7ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:18: 221.55ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:19: 182.77ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:20: 131.09ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:21: 123.6ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:22: 118.39ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:23: 183.68ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:24: 205.86ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:25: 136.18ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:26: 121.3ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:27: 127.2ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:28: 134.44ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:29: 142.78ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:30: 134.47ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:31: 132.23ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:32: 126.65ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:33: 128.65ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:34: 126.03ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:35: 140.84ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:36: 148.19ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:37: 191.8ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:38: 165.04ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:39: 95.89ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:40: 87.72ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:41: 86.36ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:42: 83.81ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:43: 77.51ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:44: 83.28ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:45: 74.54ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:46: 183.9ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:47: 104.04ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:48: 134.6ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:49: 99.55ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:50: 88.47ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:51: 82.66ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:52: 81.42ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:53: 162.89ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:54: 188.86ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:55: 100.69ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:56: 88.91ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:57: 82.14ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:58: 74.67ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:59: 146.54ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:60: 150.07ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:61: 121.1ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:62: 169.86ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:63: 193.55ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:64: 132.82ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:65: 111.52ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:66: 104.21ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:67: 90.59ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:68: 157.9ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:69: 150.31ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:70: 151.48ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:71: 88.59ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:72: 126.89ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:73: 123.27ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:74: 112.16ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:75: 103.2ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:76: 137.85ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:77: 95.52ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:78: 93.09ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:79: 76.66ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:80: 109.03ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:81: 148.17ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:82: 142.91ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:83: 135.65ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:84: 77.14ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:85: 73.67ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:86: 105.58ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:87: 113.84ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:88: 73.55ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:89: 76.81ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:90: 74.43ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:91: 144.09ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:92: 77.78ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:93: 75.75ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:94: 77.89ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:95: 75.4ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:96: 123.82ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:97: 83.38ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:98: 78.17ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder/iteration:99: 78.46ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder average: 126.82ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:0: 146.86ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:1: 137.07ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:2: 381.94ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:3: 277.05ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:4: 147.68ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:5: 144.21ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:6: 130.01ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:7: 178.19ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:8: 326.68ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:9: 180.01ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:10: 161.57ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:11: 155.27ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:12: 208.62ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:13: 217.11ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:14: 210.84ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:15: 201.23ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:16: 209.83ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:17: 139.77ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:18: 137.08ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:19: 190.56ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:20: 143.51ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:21: 137.59ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:22: 132.92ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:23: 220.75ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:24: 327.13ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:25: 268.3ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:26: 192.93ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:27: 129.66ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:28: 127.43ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:29: 226ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:30: 224.09ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:31: 161.58ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:32: 226.52ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:33: 231.01ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:34: 170.27ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:35: 148.45ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:36: 133.01ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:37: 233.12ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:38: 206.31ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:39: 210.54ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:40: 198.7ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:41: 191.87ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:42: 215.93ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:43: 353.52ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:44: 279.64ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:45: 157.43ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:46: 135.25ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:47: 129.03ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:48: 132.73ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:49: 341.34ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:50: 170.84ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:51: 153.08ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:52: 146.02ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:53: 328.01ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:54: 229.2ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:55: 202.78ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:56: 198.88ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:57: 195.94ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:58: 197.9ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:59: 208.5ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:60: 197.24ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:61: 203.2ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:62: 201ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:63: 191.72ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:64: 393.53ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:65: 242.05ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:66: 174ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:67: 147.26ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:68: 142.41ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:69: 146.81ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:70: 146.57ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:71: 301.86ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:72: 200.33ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:73: 164.7ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:74: 159.54ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:75: 174.22ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:76: 261.29ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:77: 181.16ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:78: 155.65ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:79: 156.38ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:80: 201.22ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:81: 212.52ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:82: 197.74ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:83: 295.51ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:84: 194.92ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:85: 282.89ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:86: 179.59ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:87: 146.81ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:88: 221.49ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:89: 212.54ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:90: 192.8ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:91: 196.16ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:92: 198.22ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:93: 198.38ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:94: 242.13ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:95: 258.77ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:96: 254.51ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:97: 225.48ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:98: 239.03ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions/iteration:99: 155.56ms +Primitive_Enso_Callback_Test.enso_map_as_vector_inferred_builder_and_date_conversions average: 201.46ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:0: 113.24ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:1: 199.37ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:2: 173.38ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:3: 146.48ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:4: 131.74ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:5: 113.59ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:6: 204.2ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:7: 214.42ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:8: 135.77ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:9: 125.24ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:10: 122.96ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:11: 214.93ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:12: 182.82ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:13: 127.19ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:14: 179.64ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:15: 151.15ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:16: 183.64ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:17: 175.19ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:18: 169.09ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:19: 171.78ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:20: 178.62ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:21: 177.2ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:22: 181.64ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:23: 245.4ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:24: 145.42ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:25: 261.24ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:26: 154.35ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:27: 133.23ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:28: 97.05ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:29: 79.64ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:30: 75.48ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:31: 76.39ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:32: 74.34ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:33: 156.57ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:34: 158.58ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:35: 127.31ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:36: 141.66ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:37: 128.03ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:38: 142.33ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:39: 112.65ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:40: 76.78ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:41: 100.23ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:42: 88.09ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:43: 76.79ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:44: 122.19ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:45: 76.41ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:46: 73.94ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:47: 118.62ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:48: 71.33ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:49: 77ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:50: 72.84ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:51: 168.44ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:52: 146.21ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:53: 139.58ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:54: 130.39ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:55: 165.49ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:56: 79.64ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:57: 76.51ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:58: 72.46ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:59: 71.62ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:60: 79.9ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:61: 143.45ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:62: 88.96ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:63: 76.95ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:64: 72.95ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:65: 72.39ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:66: 74.94ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:67: 130.16ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:68: 100.53ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:69: 71.33ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:70: 72.05ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:71: 71.17ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:72: 69.24ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:73: 69.77ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:74: 67.05ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:75: 207.96ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:76: 201.5ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:77: 174.34ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:78: 151.82ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:79: 121.99ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:80: 75.47ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:81: 73.41ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:82: 119.48ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:83: 169.3ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:84: 125.41ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:85: 102.95ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:86: 85.24ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:87: 82.63ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:88: 137.74ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:89: 129.45ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:90: 177.7ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:91: 77.27ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:92: 125.97ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:93: 97.92ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:94: 114.18ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:95: 76.63ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:96: 131.61ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:97: 88.62ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:98: 77.23ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder/iteration:99: 141.26ms +Primitive_Enso_Callback_Test.enso_map_as_vector_long_builder average: 124.15ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:0: 551.94ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:1: 280.45ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:2: 317.17ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:3: 274.07ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:4: 82.36ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:5: 73.62ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:6: 70.05ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:7: 66.8ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:8: 64.83ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:9: 66.56ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:10: 66.05ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:11: 69.56ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:12: 63.06ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:13: 64.85ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:14: 62.86ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:15: 67.2ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:16: 64.71ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:17: 66.59ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:18: 64.74ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:19: 70.74ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:20: 62.62ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:21: 62.48ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:22: 62.9ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:23: 63.6ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:24: 67.45ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:25: 65.29ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:26: 65.95ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:27: 64.69ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:28: 66.2ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:29: 65.11ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:30: 73.03ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:31: 79.57ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:32: 65.08ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:33: 64.35ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:34: 64.43ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:35: 63.06ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:36: 64.46ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:37: 62.76ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:38: 63.91ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:39: 65.91ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:40: 65ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:41: 65.82ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:42: 67.8ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:43: 67.15ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:44: 65.17ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:45: 68.18ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:46: 69.38ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:47: 69.92ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:48: 68.96ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:49: 69.21ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:50: 68.94ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:51: 68.3ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:52: 67.51ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:53: 69.59ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:54: 70.28ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:55: 67.24ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:56: 69.89ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:57: 71.38ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:58: 68.87ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:59: 69.75ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:60: 69.73ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:61: 76.11ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:62: 68.69ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:63: 68.57ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:64: 67.52ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:65: 68.01ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:66: 69.17ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:67: 69.46ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:68: 68.95ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:69: 68.1ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:70: 68.28ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:71: 68.07ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:72: 69.67ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:73: 68ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:74: 71.39ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:75: 66.77ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:76: 63.65ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:77: 64.92ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:78: 66.62ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:79: 64.64ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:80: 63.77ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:81: 63.33ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:82: 62.81ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:83: 63.4ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:84: 62.69ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:85: 63.25ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:86: 62.53ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:87: 65.02ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:88: 64.41ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:89: 65.14ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:90: 67.02ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:91: 66.59ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:92: 66.36ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:93: 65.14ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:94: 65.43ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:95: 65.15ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:96: 66.39ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:97: 65.34ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:98: 63.63ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed/iteration:99: 68.74ms +Primitive_Enso_Callback_Test.enso_map_with_builder_2_calls_unboxed average: 78.52ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:0: 392.39ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:1: 237.04ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:2: 207.31ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:3: 312.9ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:4: 259.22ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:5: 62.45ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:6: 59.08ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:7: 58.78ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:8: 58.91ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:9: 60.81ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:10: 67.74ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:11: 64.94ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:12: 61.43ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:13: 59.23ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:14: 56.84ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:15: 52.81ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:16: 52.84ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:17: 56.21ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:18: 56.87ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:19: 67.33ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:20: 90.28ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:21: 69.87ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:22: 66.66ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:23: 62.48ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:24: 61.56ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:25: 58.11ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:26: 57.37ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:27: 54.08ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:28: 53.41ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:29: 52.88ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:30: 51.71ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:31: 50.8ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:32: 50.64ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:33: 50.83ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:34: 50.95ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:35: 51.83ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:36: 59.59ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:37: 53.69ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:38: 57.99ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:39: 79.69ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:40: 78.74ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:41: 82.47ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:42: 62.36ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:43: 58.7ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:44: 56.56ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:45: 60.97ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:46: 53.2ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:47: 54.63ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:48: 61.79ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:49: 72.63ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:50: 51.71ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:51: 54.19ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:52: 56.39ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:53: 55.69ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:54: 52.91ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:55: 55.63ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:56: 54.23ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:57: 57.65ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:58: 77.42ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:59: 93.43ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:60: 67.42ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:61: 63.15ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:62: 60.77ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:63: 57.34ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:64: 56.44ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:65: 55.53ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:66: 54.61ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:67: 54.38ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:68: 54.82ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:69: 56.1ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:70: 55ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:71: 53.85ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:72: 54.27ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:73: 54.37ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:74: 56.92ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:75: 56.49ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:76: 69.75ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:77: 98.4ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:78: 70.26ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:79: 63.99ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:80: 62.08ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:81: 61.07ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:82: 58.21ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:83: 57.38ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:84: 55.34ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:85: 56.62ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:86: 54.13ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:87: 53.81ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:88: 52.75ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:89: 51.97ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:90: 52.26ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:91: 55.15ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:92: 57.8ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:93: 73.58ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:94: 81.22ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:95: 71.23ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:96: 64.89ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:97: 60.45ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:98: 59.33ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed/iteration:99: 60.31ms +Primitive_Enso_Callback_Test.enso_map_with_builder_1_call_boxed average: 71.54ms +Boxed_Enso_Callback_Test.current_implementation/iteration:0: 467.76ms +Boxed_Enso_Callback_Test.current_implementation/iteration:1: 575.12ms +Boxed_Enso_Callback_Test.current_implementation/iteration:2: 397.33ms +Boxed_Enso_Callback_Test.current_implementation/iteration:3: 319.48ms +Boxed_Enso_Callback_Test.current_implementation/iteration:4: 490.98ms +Boxed_Enso_Callback_Test.current_implementation/iteration:5: 251.65ms +Boxed_Enso_Callback_Test.current_implementation/iteration:6: 359.86ms +Boxed_Enso_Callback_Test.current_implementation/iteration:7: 425.97ms +Boxed_Enso_Callback_Test.current_implementation/iteration:8: 276.25ms +Boxed_Enso_Callback_Test.current_implementation/iteration:9: 511.06ms +Boxed_Enso_Callback_Test.current_implementation/iteration:10: 345.19ms +Boxed_Enso_Callback_Test.current_implementation/iteration:11: 377.63ms +Boxed_Enso_Callback_Test.current_implementation/iteration:12: 384.56ms +Boxed_Enso_Callback_Test.current_implementation/iteration:13: 253.24ms +Boxed_Enso_Callback_Test.current_implementation/iteration:14: 556.28ms +Boxed_Enso_Callback_Test.current_implementation/iteration:15: 437.74ms +Boxed_Enso_Callback_Test.current_implementation/iteration:16: 288.62ms +Boxed_Enso_Callback_Test.current_implementation/iteration:17: 267.07ms +Boxed_Enso_Callback_Test.current_implementation/iteration:18: 226.71ms +Boxed_Enso_Callback_Test.current_implementation/iteration:19: 546.06ms +Boxed_Enso_Callback_Test.current_implementation/iteration:20: 248.88ms +Boxed_Enso_Callback_Test.current_implementation/iteration:21: 220.95ms +Boxed_Enso_Callback_Test.current_implementation/iteration:22: 422.7ms +Boxed_Enso_Callback_Test.current_implementation/iteration:23: 501.06ms +Boxed_Enso_Callback_Test.current_implementation/iteration:24: 272.86ms +Boxed_Enso_Callback_Test.current_implementation/iteration:25: 421.38ms +Boxed_Enso_Callback_Test.current_implementation/iteration:26: 370.02ms +Boxed_Enso_Callback_Test.current_implementation/iteration:27: 336.34ms +Boxed_Enso_Callback_Test.current_implementation/iteration:28: 358.42ms +Boxed_Enso_Callback_Test.current_implementation/iteration:29: 358.95ms +Boxed_Enso_Callback_Test.current_implementation/iteration:30: 352.26ms +Boxed_Enso_Callback_Test.current_implementation/iteration:31: 353.41ms +Boxed_Enso_Callback_Test.current_implementation/iteration:32: 546.73ms +Boxed_Enso_Callback_Test.current_implementation/iteration:33: 434.87ms +Boxed_Enso_Callback_Test.current_implementation/iteration:34: 253.82ms +Boxed_Enso_Callback_Test.current_implementation/iteration:35: 199.98ms +Boxed_Enso_Callback_Test.current_implementation/iteration:36: 233.43ms +Boxed_Enso_Callback_Test.current_implementation/iteration:37: 592.79ms +Boxed_Enso_Callback_Test.current_implementation/iteration:38: 248.15ms +Boxed_Enso_Callback_Test.current_implementation/iteration:39: 374.2ms +Boxed_Enso_Callback_Test.current_implementation/iteration:40: 390.75ms +Boxed_Enso_Callback_Test.current_implementation/iteration:41: 353.18ms +Boxed_Enso_Callback_Test.current_implementation/iteration:42: 348.93ms +Boxed_Enso_Callback_Test.current_implementation/iteration:43: 338.53ms +Boxed_Enso_Callback_Test.current_implementation/iteration:44: 627.01ms +Boxed_Enso_Callback_Test.current_implementation/iteration:45: 284.89ms +Boxed_Enso_Callback_Test.current_implementation/iteration:46: 239.26ms +Boxed_Enso_Callback_Test.current_implementation/iteration:47: 425.43ms +Boxed_Enso_Callback_Test.current_implementation/iteration:48: 354.29ms +Boxed_Enso_Callback_Test.current_implementation/iteration:49: 232.47ms +Boxed_Enso_Callback_Test.current_implementation/iteration:50: 410.19ms +Boxed_Enso_Callback_Test.current_implementation/iteration:51: 382.05ms +Boxed_Enso_Callback_Test.current_implementation/iteration:52: 365.72ms +Boxed_Enso_Callback_Test.current_implementation/iteration:53: 368.69ms +Boxed_Enso_Callback_Test.current_implementation/iteration:54: 342.75ms +Boxed_Enso_Callback_Test.current_implementation/iteration:55: 656.89ms +Boxed_Enso_Callback_Test.current_implementation/iteration:56: 260.32ms +Boxed_Enso_Callback_Test.current_implementation/iteration:57: 235.48ms +Boxed_Enso_Callback_Test.current_implementation/iteration:58: 438.65ms +Boxed_Enso_Callback_Test.current_implementation/iteration:59: 370.83ms +Boxed_Enso_Callback_Test.current_implementation/iteration:60: 213.93ms +Boxed_Enso_Callback_Test.current_implementation/iteration:61: 442.08ms +Boxed_Enso_Callback_Test.current_implementation/iteration:62: 384.12ms +Boxed_Enso_Callback_Test.current_implementation/iteration:63: 357.03ms +Boxed_Enso_Callback_Test.current_implementation/iteration:64: 345.55ms +Boxed_Enso_Callback_Test.current_implementation/iteration:65: 578.79ms +Boxed_Enso_Callback_Test.current_implementation/iteration:66: 366.07ms +Boxed_Enso_Callback_Test.current_implementation/iteration:67: 243.3ms +Boxed_Enso_Callback_Test.current_implementation/iteration:68: 222.27ms +Boxed_Enso_Callback_Test.current_implementation/iteration:69: 215.63ms +Boxed_Enso_Callback_Test.current_implementation/iteration:70: 583.18ms +Boxed_Enso_Callback_Test.current_implementation/iteration:71: 271.32ms +Boxed_Enso_Callback_Test.current_implementation/iteration:72: 386.22ms +Boxed_Enso_Callback_Test.current_implementation/iteration:73: 386.57ms +Boxed_Enso_Callback_Test.current_implementation/iteration:74: 337.98ms +Boxed_Enso_Callback_Test.current_implementation/iteration:75: 343.54ms +Boxed_Enso_Callback_Test.current_implementation/iteration:76: 535.54ms +Boxed_Enso_Callback_Test.current_implementation/iteration:77: 423.55ms +Boxed_Enso_Callback_Test.current_implementation/iteration:78: 225.9ms +Boxed_Enso_Callback_Test.current_implementation/iteration:79: 242.87ms +Boxed_Enso_Callback_Test.current_implementation/iteration:80: 443.02ms +Boxed_Enso_Callback_Test.current_implementation/iteration:81: 379.62ms +Boxed_Enso_Callback_Test.current_implementation/iteration:82: 226.87ms +Boxed_Enso_Callback_Test.current_implementation/iteration:83: 349.72ms +Boxed_Enso_Callback_Test.current_implementation/iteration:84: 360.03ms +Boxed_Enso_Callback_Test.current_implementation/iteration:85: 359.5ms +Boxed_Enso_Callback_Test.current_implementation/iteration:86: 362.7ms +Boxed_Enso_Callback_Test.current_implementation/iteration:87: 321.71ms +Boxed_Enso_Callback_Test.current_implementation/iteration:88: 526.79ms +Boxed_Enso_Callback_Test.current_implementation/iteration:89: 414.14ms +Boxed_Enso_Callback_Test.current_implementation/iteration:90: 254.55ms +Boxed_Enso_Callback_Test.current_implementation/iteration:91: 206.18ms +Boxed_Enso_Callback_Test.current_implementation/iteration:92: 195.27ms +Boxed_Enso_Callback_Test.current_implementation/iteration:93: 608.27ms +Boxed_Enso_Callback_Test.current_implementation/iteration:94: 232.54ms +Boxed_Enso_Callback_Test.current_implementation/iteration:95: 379.29ms +Boxed_Enso_Callback_Test.current_implementation/iteration:96: 410.92ms +Boxed_Enso_Callback_Test.current_implementation/iteration:97: 354.93ms +Boxed_Enso_Callback_Test.current_implementation/iteration:98: 342.84ms +Boxed_Enso_Callback_Test.current_implementation/iteration:99: 502.33ms +Boxed_Enso_Callback_Test.current_implementation average: 366.23ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:0: 294.96ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:1: 224.19ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:2: 132.34ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:3: 143.75ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:4: 126.24ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:5: 92.53ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:6: 306.51ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:7: 194.81ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:8: 123.32ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:9: 106.05ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:10: 116.23ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:11: 255.51ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:12: 200.24ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:13: 190.87ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:14: 182.3ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:15: 179.18ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:16: 180.23ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:17: 185.42ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:18: 179.87ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:19: 366.59ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:20: 265.85ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:21: 176.2ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:22: 126.05ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:23: 132.13ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:24: 117.07ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:25: 100.85ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:26: 93.14ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:27: 323.57ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:28: 121.19ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:29: 114.7ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:30: 99.62ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:31: 97.93ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:32: 251.42ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:33: 203.87ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:34: 190.03ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:35: 125.17ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:36: 108.06ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:37: 98ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:38: 96.41ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:39: 320.45ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:40: 235.13ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:41: 123.74ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:42: 105.56ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:43: 94.93ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:44: 280.56ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:45: 234.02ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:46: 192.72ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:47: 176.76ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:48: 170.27ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:49: 171.77ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:50: 179.09ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:51: 156.98ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:52: 343.88ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:53: 239.94ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:54: 253.26ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:55: 152.04ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:56: 102.61ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:57: 105.38ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:58: 95.32ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:59: 109.9ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:60: 304.84ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:61: 151.74ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:62: 139.2ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:63: 100.09ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:64: 99.7ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:65: 243.65ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:66: 202.09ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:67: 175.72ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:68: 126.18ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:69: 104.77ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:70: 95.38ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:71: 227.67ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:72: 216.24ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:73: 133.82ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:74: 108.68ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:75: 227.85ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:76: 195ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:77: 200.08ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:78: 186.73ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:79: 181.16ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:80: 185.83ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:81: 177ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:82: 178.61ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:83: 165.09ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:84: 323.01ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:85: 265.79ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:86: 164.07ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:87: 118.73ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:88: 105.04ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:89: 100.61ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:90: 99.26ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:91: 293.41ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:92: 194.91ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:93: 127.83ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:94: 109.43ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:95: 100.69ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:96: 269.58ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:97: 221.95ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:98: 197.73ms +Boxed_Enso_Callback_Test.java_roundtrip/iteration:99: 195.26ms +Boxed_Enso_Callback_Test.java_roundtrip average: 174.81ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:0: 338.35ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:1: 343.01ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:2: 305.61ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:3: 585.24ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:4: 312.6ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:5: 201.53ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:6: 198.57ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:7: 451.79ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:8: 349.4ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:9: 206.96ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:10: 352.72ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:11: 334.61ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:12: 302.28ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:13: 333.14ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:14: 318.39ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:15: 295.4ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:16: 591.8ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:17: 283.85ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:18: 210.8ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:19: 203.89ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:20: 501.13ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:21: 330.77ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:22: 271.39ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:23: 325.7ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:24: 317.01ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:25: 303.66ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:26: 279.95ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:27: 269.43ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:28: 272.59ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:29: 534.7ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:30: 368.49ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:31: 222.08ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:32: 171.29ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:33: 171.34ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:34: 161.71ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:35: 513.46ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:36: 181.12ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:37: 163.48ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:38: 366.98ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:39: 360.6ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:40: 206.5ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:41: 173.16ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:42: 176.54ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:43: 157.58ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:44: 424.63ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:45: 175.41ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:46: 160.71ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:47: 362.9ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:48: 348.94ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:49: 208.13ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:50: 178.99ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:51: 513.29ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:52: 224.83ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:53: 360.75ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:54: 315.06ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:55: 276ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:56: 269.12ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:57: 477.76ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:58: 366.28ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:59: 232.09ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:60: 220.55ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:61: 282.39ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:62: 410.84ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:63: 399.05ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:64: 198.71ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:65: 175.62ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:66: 570.1ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:67: 294.68ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:68: 334.84ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:69: 298.56ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:70: 283.18ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:71: 286.86ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:72: 498.52ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:73: 319.23ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:74: 217.02ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:75: 179.11ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:76: 280.12ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:77: 435.47ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:78: 349.6ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:79: 194.18ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:80: 169.26ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:81: 478.33ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:82: 211.46ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:83: 353.39ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:84: 314.54ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:85: 282.12ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:86: 297.37ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:87: 478.06ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:88: 395.83ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:89: 210.76ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:90: 219.13ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:91: 243.84ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:92: 452.53ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:93: 349.58ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:94: 194.12ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:95: 188.55ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:96: 484.73ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:97: 233.51ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:98: 369ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion/iteration:99: 292.21ms +Boxed_Enso_Callback_Test.enso_map_as_vector_without_date_conversion average: 306.62ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:0: 350.55ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:1: 325.93ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:2: 513.65ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:3: 408.93ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:4: 245.37ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:5: 272.99ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:6: 443.5ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:7: 263.51ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:8: 208.96ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:9: 390.08ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:10: 405.73ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:11: 230.6ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:12: 200.07ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:13: 457.36ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:14: 253.21ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:15: 197.69ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:16: 501.91ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:17: 303.39ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:18: 212.32ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:19: 361.53ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:20: 423.74ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:21: 218.37ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:22: 413.69ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:23: 368.2ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:24: 361.1ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:25: 443.61ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:26: 256.08ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:27: 205.84ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:28: 383.58ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:29: 429.23ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:30: 321.39ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:31: 195.93ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:32: 475.1ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:33: 400.47ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:34: 247.18ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:35: 383.81ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:36: 367.22ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:37: 322.1ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:38: 375.92ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:39: 344.33ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:40: 345.5ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:41: 354.22ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:42: 518.75ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:43: 393.23ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:44: 246.78ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:45: 236.17ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:46: 211.39ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:47: 498.65ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:48: 214.2ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:49: 205.73ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:50: 548.57ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:51: 364.6ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:52: 241.21ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:53: 234.61ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:54: 424.79ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:55: 211.87ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:56: 345.01ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:57: 372.03ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:58: 346.21ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:59: 355.84ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:60: 454.36ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:61: 220.56ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:62: 200.51ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:63: 395.76ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:64: 473.82ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:65: 234.95ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:66: 220.62ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:67: 486.21ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:68: 286.85ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:69: 209.32ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:70: 188.44ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:71: 419.54ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:72: 343.95ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:73: 302.5ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:74: 289.8ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:75: 181.91ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:76: 455.51ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:77: 236.91ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:78: 207.07ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:79: 211.53ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:80: 479.99ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:81: 394.14ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:82: 236.11ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:83: 193.94ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:84: 218.25ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:85: 511.43ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:86: 224.56ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:87: 200.83ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:88: 207.68ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:89: 366.92ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:90: 335.23ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:91: 350.2ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:92: 271.69ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:93: 189.48ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:94: 203.41ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:95: 486.78ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:96: 208.21ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:97: 192.44ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:98: 204.15ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion/iteration:99: 477.02ms +Boxed_Enso_Callback_Test.enso_map_as_vector_with_date_conversion average: 321.26ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:0: 910.39ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:1: 336.52ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:2: 317.96ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:3: 341.78ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:4: 147.09ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:5: 333.18ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:6: 161.34ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:7: 151.15ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:8: 159ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:9: 141.39ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:10: 131.81ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:11: 133.03ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:12: 127.93ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:13: 380.41ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:14: 263.46ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:15: 240.69ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:16: 163.11ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:17: 160.17ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:18: 168.13ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:19: 149.88ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:20: 351.7ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:21: 175.02ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:22: 151.92ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:23: 148.04ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:24: 278.38ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:25: 250.62ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:26: 251.33ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:27: 173.93ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:28: 158.48ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:29: 141.72ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:30: 261.46ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:31: 165.57ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:32: 153.18ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:33: 144.76ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:34: 267.86ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:35: 265.57ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:36: 245.49ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:37: 163.53ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:38: 165.37ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:39: 142.97ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:40: 267.85ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:41: 169.3ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:42: 145.29ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:43: 141.55ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:44: 294.78ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:45: 230.97ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:46: 195.08ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:47: 209.36ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:48: 220.04ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:49: 213ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:50: 224.9ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:51: 204.89ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:52: 210.98ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:53: 471.81ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:54: 192.65ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:55: 157.91ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:56: 186.63ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:57: 157.35ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:58: 143.23ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:59: 332.12ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:60: 191.66ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:61: 156.79ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:62: 146.92ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:63: 136.24ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:64: 137.18ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:65: 323.73ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:66: 247.79ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:67: 234.36ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:68: 212.11ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:69: 210.19ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:70: 211.33ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:71: 221.81ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:72: 210.04ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:73: 176.83ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:74: 122.05ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:75: 312.8ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:76: 180.34ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:77: 150.88ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:78: 135.07ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:79: 128.2ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:80: 145.7ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:81: 134.1ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:82: 127.98ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:83: 490.87ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:84: 240.45ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:85: 174.61ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:86: 150.78ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:87: 148.4ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:88: 143.74ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:89: 232.27ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:90: 274.99ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:91: 174.02ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:92: 155.66ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:93: 138.4ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:94: 129.87ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:95: 127.27ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:96: 127.04ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:97: 344.35ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:98: 317.59ms +Boxed_Enso_Callback_Test.enso_map_with_builder/iteration:99: 264.63ms +Boxed_Enso_Callback_Test.enso_map_with_builder average: 212.34ms \ No newline at end of file diff --git a/tools/performance/benchmark-analysis/package.yaml b/tools/performance/benchmark-analysis/package.yaml new file mode 100644 index 00000000000..f652f8d5b41 --- /dev/null +++ b/tools/performance/benchmark-analysis/package.yaml @@ -0,0 +1,8 @@ +name: Vectorized_Benchmarks +namespace: local +version: 0.0.1 +license: "" +authors: [] +maintainers: [] +edition: 0.0.0-dev +prefer-local-libraries: true diff --git a/tools/performance/benchmark-analysis/src/Main.enso b/tools/performance/benchmark-analysis/src/Main.enso new file mode 100644 index 00000000000..894247bd27d --- /dev/null +++ b/tools/performance/benchmark-analysis/src/Main.enso @@ -0,0 +1,59 @@ +from Standard.Base import all +from Standard.Table import all +from Standard.Database import all +from Standard.AWS import all +import Standard.Visualization + +main = + text1 = "(?.*)\.(?.*)/.*:(?\d+): (?