text: /*
   * Javascript Micro benchmark
   *
   * Copyright (c) 2017-2019 Fabrice Bellard
   * Copyright (c) 2017-2019 Charlie Gordon
   *
   * Permission is hereby granted, free of charge, to any person obtaining a copy
   * of this software and associated documentation files (the "Software"), to deal
   * in the Software without restriction, including without limitation the rights
   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   * copies of the Software, and to permit persons to whom the Software is
   * furnished to do so, subject to the following conditions:
   *
   * The above copyright notice and this permission notice shall be included in
   * all copies or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
   * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   * THE SOFTWARE.
   */
  import * as std from "std";
  
  function pad(str, n) {
      str += "";
      while (str.length < n)
          str += " ";
      return str;
  }
  
  function pad_left(str, n) {
      str += "";
      while (str.length < n)
          str = " " + str;
      return str;
  }
  
  function pad_center(str, n) {
      str += "";
      while (str.length < n) {
          if ((n - str.length) & 1)
              str = str + " ";
          else
              str = " " + str;
      }
      return str;
  }
  
  function toPrec(n, prec) {
      var i, s;
      for (i = 0; i < prec; i++)
          n *= 10;
      s = "" + Math.round(n);
      for (i = s.length - prec; i <= 0; i++)
          s = "0" + s;
      if (prec > 0)
          s = s.substring(0, i) + "." + s.substring(i);
      return s;
  }
                  
  var ref_data;
  var log_data;
  
  var heads  = [ "TEST", "N", "TIME (ns)", "REF (ns)", "SCORE (%)" ];
  var widths = [    22,   10,          9,     9,       9 ];
  var precs  = [     0,   0,           2,     2,       2 ];
  var total  = [     0,   0,           0,     0,       0 ];
  var total_score = 0;
  var total_scale = 0;
  
  if (typeof console == "undefined") {
      var console = { log: print };
  }
  
  function log_line() {
      var i, n, s, a;
      s = "";
      for (i = 0, n = arguments.length; i < n; i++) {
          if (i > 0)
              s += " ";
          a = arguments[i];
          if (typeof a == "number") {
              total[i] += a;
              a = toPrec(a, precs[i]);
              s += pad_left(a, widths[i]);
          } else {
              s += pad_left(a, widths[i]);
          }
      }
      console.log(s);
  }
  
  var clocks_per_sec = 1000000;
  var max_iterations = 100;
  var clock_threshold = 2000;  /* favoring short measuring spans */
  var min_n_argument = 1;
  var get_clock;
  
  if (typeof globalThis.__date_clock != "function") {
      console.log("using fallback millisecond clock");
      clocks_per_sec = 1000;
      max_iterations = 10;
      clock_threshold = 100;
      get_clock = Date.now;
  } else {
      get_clock = globalThis.__date_clock;
  }
  
  function log_one(text, n, ti) {
      var ref;
  
      if (ref_data)
          ref = ref_data[text];
      else
          ref = null;
  
      ti = Math.round(ti * 100) / 100;
      log_data[text] = ti;
      if (typeof ref === "number") {
          log_line(text, n, ti, ref, ti * 100 / ref);
          total_score += ti * 100 / ref;
          total_scale += 100;
      } else {
          log_line(text, n, ti);
          total_score += 100;
          total_scale += 100;
      }
  }
  
  function bench(f, text)
  {
      var i, j, n, t, t1, ti, nb_its, ref, ti_n, ti_n1, min_ti;
  
      nb_its = n = 1;
      if (f.bench) {
          ti_n = f(text);
      } else {
          ti_n = 1000000000;
          min_ti = clock_threshold / 10;
          for(i = 0; i < 30; i++) {
              ti = 1000000000;
              for (j = 0; j < max_iterations; j++) {
                  t = get_clock();
                  while ((t1 = get_clock()) == t)
                      continue;
                  nb_its = f(n);
                  if (nb_its < 0)
                      return; // test failure
                  t1 = get_clock() - t1;
                  if (ti > t1)
                      ti = t1;
              }
              if (ti >= min_ti) {
                  ti_n1 = ti / nb_its;
                  if (ti_n > ti_n1)
                      ti_n = ti_n1;
              }
              if (ti >= clock_threshold && n >= min_n_argument)
                  break;
  
              n = n * [ 2, 2.5, 2 ][i % 3];
          }
          // to use only the best timing from the last loop, uncomment below
          //ti_n = ti / nb_its;
      }
      /* nano seconds per iteration */
      log_one(text, n, ti_n * 1e9 / clocks_per_sec);
  }
  
  var global_res; /* to be sure the code is not optimized */
  
  function empty_loop(n) {
      var j;
      for(j = 0; j < n; j++) {
      }
      return n;
  }
  
  function date_now(n) {
      var j;
      for(j = 0; j < n; j++) {
          Date.now();
      }
      return n;
  }
  
  function prop_read(n)
  {
      var obj, sum, j;
      obj = {a: 1, b: 2, c:3, d:4 };
      sum = 0;
      for(j = 0; j < n; j++) {
          sum += obj.a;
          sum += obj.b;
          sum += obj.c;
          sum += obj.d;
      }
      global_res = sum;
      return n * 4;
  }
  
  function prop_write(n)
  {
      var obj, j;
      obj = {a: 1, b: 2, c:3, d:4 };
      for(j = 0; j < n; j++) {
          obj.a = j;
          obj.b = j;
          obj.c = j;
          obj.d = j;
      }
      return n * 4;
  }
  
  function prop_create(n)
  {
      var obj, j;
      for(j = 0; j < n; j++) {
          obj = new Object();
          obj.a = 1;
          obj.b = 2;
          obj.c = 3;
          obj.d = 4;
      }
      return n * 4;
  }
  
  function array_read(n)
  {
      var tab, len, sum, i, j;
      tab = [];
      len = 10;
      for(i = 0; i < len; i++)
          tab[i] = i;
      sum = 0;
      for(j = 0; j < n; j++) {
          sum += tab[0];
          sum += tab[1];
          sum += tab[2];
          sum += tab[3];
          sum += tab[4];
          sum += tab[5];
          sum += tab[6];
          sum += tab[7];
          sum += tab[8];
          sum += tab[9];
      }
      global_res = sum;
      return len * n;
  }
  
  function array_write(n)
  {
      var tab, len, i, j;
      tab = [];
      len = 10;
      for(i = 0; i < len; i++)
          tab[i] = i;
      for(j = 0; j < n; j++) {
          tab[0] = j;
          tab[1] = j;
          tab[2] = j;
          tab[3] = j;
          tab[4] = j;
          tab[5] = j;
          tab[6] = j;
          tab[7] = j;
          tab[8] = j;
          tab[9] = j;
      }
      return len * n;
  }
  
  function array_prop_create(n)
  {
      var tab, i, j, len;
      len = 1000;
      for(j = 0; j < n; j++) {
          tab = [];
          for(i = 0; i < len; i++)
              tab[i] = i;
      }
      return len * n;
  }
  
  function array_length_decr(n)
  {
      var tab, i, j, len;
      len = 1000;
      tab = [];
      for(i = 0; i < len; i++)
          tab[i] = i;
      for(j = 0; j < n; j++) {
          for(i = len - 1; i >= 0; i--)
              tab.length = i;
      }
      return len * n;
  }
  
  function array_hole_length_decr(n)
  {
      var tab, i, j, len;
      len = 1000;
      tab = [];
      for(i = 0; i < len; i++) {
          if (i != 3)
              tab[i] = i;
      }
      for(j = 0; j < n; j++) {
          for(i = len - 1; i >= 0; i--)
              tab.length = i;
      }
      return len * n;
  }
  
  function array_push(n)
  {
      var tab, i, j, len;
      len = 500;
      for(j = 0; j < n; j++) {
          tab = [];
          for(i = 0; i < len; i++)
              tab.push(i);
      }
      return len * n;
  }
  
  function array_pop(n)
  {
      var tab, i, j, len, sum;
      len = 500;
      for(j = 0; j < n; j++) {
          tab = [];
          for(i = 0; i < len; i++)
              tab[i] = i;
          sum = 0;
          for(i = 0; i < len; i++)
              sum += tab.pop();
          global_res = sum;
      }
      return len * n;
  }
  
  function typed_array_read(n)
  {
      var tab, len, sum, i, j;
      len = 10;
      tab = new Int32Array(len);
      for(i = 0; i < len; i++)
          tab[i] = i;
      sum = 0;
      for(j = 0; j < n; j++) {
          sum += tab[0];
          sum += tab[1];
          sum += tab[2];
          sum += tab[3];
          sum += tab[4];
          sum += tab[5];
          sum += tab[6];
          sum += tab[7];
          sum += tab[8];
          sum += tab[9];
      }
      global_res = sum;
      return len * n;
  }
  
  function typed_array_write(n)
  {
      var tab, len, i, j;
      len = 10;
      tab = new Int32Array(len);
      for(i = 0; i < len; i++)
          tab[i] = i;
      for(j = 0; j < n; j++) {
          tab[0] = j;
          tab[1] = j;
          tab[2] = j;
          tab[3] = j;
          tab[4] = j;
          tab[5] = j;
          tab[6] = j;
          tab[7] = j;
          tab[8] = j;
          tab[9] = j;
      }
      return len * n;
  }
  
  var global_var0;
  
  function global_read(n)
  {
      var sum, j;
      global_var0 = 0;
      sum = 0;
      for(j = 0; j < n; j++) {
          sum += global_var0;
          sum += global_var0;
          sum += global_var0;
          sum += global_var0;
      }
      global_res = sum;
      return n * 4;
  }
  
  var global_write =
      (1, eval)(`(function global_write(n)
             {
                 var j;
                 for(j = 0; j < n; j++) {
                     global_var0 = j;
                     global_var0 = j;
                     global_var0 = j;
                     global_var0 = j;
                 }
                 return n * 4;
             })`);
  
  function global_write_strict(n)
  {
      var j;
      for(j = 0; j < n; j++) {
          global_var0 = j;
          global_var0 = j;
          global_var0 = j;
          global_var0 = j;
      }
      return n * 4;
  }
  
  function local_destruct(n)
  {
      var j, v1, v2, v3, v4;
      var array = [ 1, 2, 3, 4, 5];
      var o = { a:1, b:2, c:3, d:4 };
      var a, b, c, d;
      for(j = 0; j < n; j++) {
          [ v1, v2,, v3, ...v4] = array;
          ({ a, b, c, d } = o);
          ({ a: a, b: b, c: c, d: d } = o);
      }
      return n * 12;
  }
  
  var global_v1, global_v2, global_v3, global_v4;
  var global_a, global_b, global_c, global_d;
  
  var global_destruct =
      (1, eval)(`(function global_destruct(n)
             {
                 var j, v1, v2, v3, v4;
                 var array = [ 1, 2, 3, 4, 5 ];
                 var o = { a:1, b:2, c:3, d:4 };
                 var a, b, c, d;
                 for(j = 0; j < n; j++) {
                     [ global_v1, global_v2,, global_v3, ...global_v4] = array;
                     ({ a: global_a, b: global_b, c: global_c, d: global_d } = o);
                 }
                 return n * 8;
            })`);
  
  function global_destruct_strict(n)
  {
      var j, v1, v2, v3, v4;
      var array = [ 1, 2, 3, 4, 5 ];
      var o = { a:1, b:2, c:3, d:4 };
      var a, b, c, d;
      for(j = 0; j < n; j++) {
          [ global_v1, global_v2,, global_v3, ...global_v4] = array;
          ({ a: global_a, b: global_b, c: global_c, d: global_d } = o);
      }
      return n * 8;
  }
  
  function func_call(n)
  {
      function f(a)
      {
          return 1;
      }
  
      var j, sum;
      sum = 0;
      for(j = 0; j < n; j++) {
          sum += f(j);
          sum += f(j);
          sum += f(j);
          sum += f(j);
      }
      global_res = sum;
      return n * 4;
  }
  
  function closure_var(n)
  {
      function f(a)
      {
          sum++;
      }
  
      var j, sum;
      sum = 0;
      for(j = 0; j < n; j++) {
          f(j);
          f(j);
          f(j);
          f(j);
      }
      global_res = sum;
      return n * 4;
  }
  
  function int_arith(n)
  {
      var i, j, sum;
      global_res = 0;
      for(j = 0; j < n; j++) {
          sum = 0;
          for(i = 0; i < 1000; i++) {
              sum += i * i;
          }
          global_res += sum;
      }
      return n * 1000;
  }
  
  function float_arith(n)
  {
      var i, j, sum, a, incr, a0;
      global_res = 0;
      a0 = 0.1;
      incr = 1.1;
      for(j = 0; j < n; j++) {
          sum = 0;
          a = a0;
          for(i = 0; i < 1000; i++) {
              sum += a * a;
              a += incr;
          }
          global_res += sum;
      }
      return n * 1000;
  }
  
  function bigfloat_arith(n)
  {
      var i, j, sum, a, incr, a0;
      global_res = 0;
      a0 = BigFloat("0.1");
      incr = BigFloat("1.1");
      for(j = 0; j < n; j++) {
          sum = 0;
          a = a0;
          for(i = 0; i < 1000; i++) {
              sum += a * a;
              a += incr;
          }
          global_res += sum;
      }
      return n * 1000;
  }
  
  function float256_arith(n)
  {
      return BigFloatEnv.setPrec(bigfloat_arith.bind(null, n), 237, 19);
  }
  
  function bigint_arith(n, bits)
  {
      var i, j, sum, a, incr, a0, sum0;
      sum0 = global_res = BigInt(0);
      a0 = BigInt(1) << BigInt(Math.floor((bits - 10) * 0.5));
      incr = BigInt(1);
      for(j = 0; j < n; j++) {
          sum = sum0;
          a = a0;
          for(i = 0; i < 1000; i++) {
              sum += a * a;
              a += incr;
          }
          global_res += sum;
      }
      return n * 1000;
  }
  
  function bigint64_arith(n)
  {
      return bigint_arith(n, 64);
  }
  
  function bigint256_arith(n)
  {
      return bigint_arith(n, 256);
  }
  
  function set_collection_add(n)
  {
      var s, i, j, len = 100;
      s = new Set();
      for(j = 0; j < n; j++) {
          for(i = 0; i < len; i++) {
              s.add(String(i), i);
          }
          for(i = 0; i < len; i++) {
              if (!s.has(String(i)))
                  throw Error("bug in Set");
          }
      }
      return n * len;
  }
  
  function array_for(n)
  {
      var r, i, j, sum;
      r = [];
      for(i = 0; i < 100; i++)
          r[i] = i;
      for(j = 0; j < n; j++) {
          sum = 0;
          for(i = 0; i < 100; i++) {
              sum += r[i];
          }
          global_res = sum;
      }
      return n * 100;
  }
  
  function array_for_in(n)
  {
      var r, i, j, sum;
      r = [];
      for(i = 0; i < 100; i++)
          r[i] = i;
      for(j = 0; j < n; j++) {
          sum = 0;
          for(i in r) {
              sum += r[i];
          }
          global_res = sum;
      }
      return n * 100;
  }
  
  function array_for_of(n)
  {
      var r, i, j, sum;
      r = [];
      for(i = 0; i < 100; i++)
          r[i] = i;
      for(j = 0; j < n; j++) {
          sum = 0;
          for(i of r) {
              sum += i;
          }
          global_res = sum;
      }
      return n * 100;
  }
  
  function math_min(n)
  {
      var i, j, r;
      r = 0;
      for(j = 0; j < n; j++) {
          for(i = 0; i < 1000; i++)
              r = Math.min(i, 500);
          global_res = r;
      }
      return n * 1000;
  }
  
  /* incremental string contruction as local var */
  function string_build1(n)
  {
      var i, j, r;
      r = "";
      for(j = 0; j < n; j++) {
          for(i = 0; i < 100; i++)
              r += "x";
          global_res = r;
      }
      return n * 100;
  }
  
  /* incremental string contruction as arg */
  function string_build2(n, r)
  {
      var i, j;
      r = "";
      for(j = 0; j < n; j++) {
          for(i = 0; i < 100; i++)
              r += "x";
          global_res = r;
      }
      return n * 100;
  }
  
  /* incremental string contruction by prepending */
  function string_build3(n, r)
  {
      var i, j;
      r = "";
      for(j = 0; j < n; j++) {
          for(i = 0; i < 100; i++)
              r = "x" + r;
          global_res = r;
      }
      return n * 100;
  }
  
  /* incremental string contruction with multiple reference */
  function string_build4(n)
  {
      var i, j, r, s;
      r = "";
      for(j = 0; j < n; j++) {
          for(i = 0; i < 100; i++) {
              s = r;
              r += "x";
          }
          global_res = r;
      }
      return n * 100;
  }
  
  /* sort bench */
  
  function sort_bench(text) {
      function random(arr, n, def) {
          for (var i = 0; i < n; i++)
              arr[i] = def[(Math.random() * n) >> 0];
      }
      function random8(arr, n, def) {
          for (var i = 0; i < n; i++)
              arr[i] = def[(Math.random() * 256) >> 0];
      }
      function random1(arr, n, def) {
          for (var i = 0; i < n; i++)
              arr[i] = def[(Math.random() * 2) >> 0];
      }
      function hill(arr, n, def) {
          var mid = n >> 1;
          for (var i = 0; i < mid; i++)
              arr[i] = def[i];
          for (var i = mid; i < n; i++)
              arr[i] = def[n - i];
      }
      function comb(arr, n, def) {
          for (var i = 0; i < n; i++)
              arr[i] = def[(i & 1) * i];
      }
      function crisscross(arr, n, def) {
          for (var i = 0; i < n; i++)
              arr[i] = def[(i & 1) ? n - i : i];
      }
      function zero(arr, n, def) {
          for (var i = 0; i < n; i++)
              arr[i] = def[0];
      }
      function increasing(arr, n, def) {
          for (var i = 0; i < n; i++)
              arr[i] = def[i];
      }
      function decreasing(arr, n, def) {
          for (var i = 0; i < n; i++)
              arr[i] = def[n - 1 - i];
      }
      function alternate(arr, n, def) {
          for (var i = 0; i < n; i++)
              arr[i] = def[i ^ 1];
      }
      function jigsaw(arr, n, def) {
          for (var i = 0; i < n; i++)
              arr[i] = def[i % (n >> 4)];
      }
      function incbutone(arr, n, def) {
          for (var i = 0; i < n; i++)
              arr[i] = def[i];
          if (n > 0)
              arr[n >> 2] = def[n];
      }
      function incbutfirst(arr, n, def) {
          if (n > 0)
              arr[0] = def[n];
          for (var i = 1; i < n; i++)
              arr[i] = def[i];
      }
      function incbutlast(arr, n, def) {
          for (var i = 0; i < n - 1; i++)
              arr[i] = def[i + 1];
          if (n > 0)
              arr[n - 1] = def[0];
      }
  
      var sort_cases = [ random, random8, random1, jigsaw, hill, comb,
                        crisscross, zero, increasing, decreasing, alternate,
                        incbutone, incbutlast, incbutfirst ];
  
      var n = sort_bench.array_size || 10000;
      var array_type = sort_bench.array_type || Array;
      var def, arr;
      var i, j, x, y;
      var total = 0;
  
      var save_total_score = total_score;
      var save_total_scale = total_scale;
  
      // initialize default sorted array (n + 1 elements)
      def = new array_type(n + 1);
      if (array_type == Array) {
          for (i = 0; i <= n; i++) {
              def[i] = i + "";
          }
      } else {
          for (i = 0; i <= n; i++) {
              def[i] = i;
          }
      }
      def.sort();
      for (var f of sort_cases) {
          var ti = 0, tx = 0;
          for (j = 0; j < 100; j++) {
              arr = new array_type(n);
              f(arr, n, def);
              var t1 = get_clock();
              arr.sort();
              t1 = get_clock() - t1;
              tx += t1;
              if (!ti || ti > t1)
                  ti = t1;
              if (tx >= clocks_per_sec)
                  break;
          }
          total += ti;
  
          i = 0;
          x = arr[0];
          if (x !== void 0) {
              for (i = 1; i < n; i++) {
                  y = arr[i];
                  if (y === void 0)
                      break;
                  if (x > y)
                      break;
                  x = y;
              }
          }
          while (i < n && arr[i] === void 0)
              i++;
          if (i < n) {
              console.log("sort_bench: out of order error for " + f.name +
                          " at offset " + (i - 1) +
                          ": " + arr[i - 1] + " > " + arr[i]);
          }
          if (sort_bench.verbose)
              log_one("sort_" + f.name, n, ti, n * 100);
      }
      total_score = save_total_score;
      total_scale = save_total_scale;
      return total / n / 1000;
  }
  sort_bench.bench = true;
  sort_bench.verbose = false;
  
  function int_to_string(n)
  {
      var s, r, j;
      r = 0;
      for(j = 0; j < n; j++) {
          s = (j + 1).toString();
      }
      return n;
  }
  
  function float_to_string(n)
  {
      var s, r, j;
      r = 0;
      for(j = 0; j < n; j++) {
          s = (j + 0.1).toString();
      }
      return n;
  }
  
  function string_to_int(n)
  {
      var s, r, j;
      r = 0;
      s = "12345";
      r = 0;
      for(j = 0; j < n; j++) {
          r += (s | 0);
      }
      global_res = r;
      return n;
  }
  
  function string_to_float(n)
  {
      var s, r, j;
      r = 0;
      s = "12345.6";
      r = 0;
      for(j = 0; j < n; j++) {
          r -= s;
      }
      global_res = r;
      return n;
  }
  
  function load_result(filename)
  {
      var f, str, res;
      if (typeof std === "undefined")
          return null;
      f = std.open(filename, "r");
      if (!f)
          return null;
      str = f.readAsString();
      res = JSON.parse(str);
      f.close();
      return res;
  }
  
  function save_result(filename, obj)
  {
      var f;
      if (typeof std === "undefined")
          return;
      f = std.open(filename, "w");
      f.puts(JSON.stringify(obj, null, 2));
      f.puts("\n");
      f.close();
  }
  
  function main(argc, argv, g)
  {
      var test_list = [
          empty_loop,
          date_now,
          prop_read,
          prop_write,
          prop_create,
          array_read,
          array_write,
          array_prop_create,
          array_length_decr,
          array_hole_length_decr,
          array_push,
          array_pop,
          typed_array_read,
          typed_array_write,
          global_read,
          global_write,
          global_write_strict,
          local_destruct,
          global_destruct,
          global_destruct_strict,
          func_call,
          closure_var,
          int_arith,
          float_arith,
          set_collection_add,
          array_for,
          array_for_in,
          array_for_of,
          math_min,
          string_build1,
          string_build2,
          //string_build3,
          //string_build4,
          sort_bench,
          int_to_string,
          float_to_string,
          string_to_int,
          string_to_float,
      ];
      var tests = [];
      var i, j, n, f, name;
      
      if (typeof BigInt == "function") {
          /* BigInt test */
          test_list.push(bigint64_arith);
          test_list.push(bigint256_arith);
      }
      if (typeof BigFloat == "function") {
          /* BigFloat test */
          test_list.push(float256_arith);
      }
      
      for (i = 1; i < argc;) {
          name = argv[i++];
          if (name == "-a") {
              sort_bench.verbose = true;
              continue;
          }
          if (name == "-t") {
              name = argv[i++];
              sort_bench.array_type = g[name];
              if (typeof sort_bench.array_type != "function") {
                  console.log("unknown array type: " + name);
                  return 1;
              }
              continue;
          }
          if (name == "-n") {
              sort_bench.array_size = +argv[i++];
              continue;
          }
          for (j = 0; j < test_list.length; j++) {
              f = test_list[j];
              if (name === f.name) {
                  tests.push(f);
                  break;
              }
          }
          if (j == test_list.length) {
              console.log("unknown benchmark: " + name);
              return 1;
          }
      }
      if (tests.length == 0)
          tests = test_list;
  
      ref_data = load_result("microbench.txt");
      log_data = {};
      log_line.apply(null, heads);
      n = 0;
  
      for(i = 0; i < tests.length; i++) {
          f = tests[i];
          bench(f, f.name, ref_data, log_data);
          if (ref_data && ref_data[f.name])
              n++;
      }
      if (ref_data)
          log_line("total", "", total[2], total[3], total_score * 100 / total_scale);
      else
          log_line("total", "", total[2]);
          
      if (tests == test_list)
          save_result("microbench-new.txt", log_data);
  }
  
  if (!scriptArgs)
      scriptArgs = [];
  main(scriptArgs.length, scriptArgs, this);
  