//Provides: bls_allocate_mlbytes
//Requires: MlBytes, caml_failwith, caml_array_of_bytes
function bls_allocate_mlbytes(x) {
  var g = globalThis;
  var M = g._BLS12381;
  if (!M) caml_failwith('bls12-381 was not initialized');
  var a = caml_array_of_bytes(x);
  var p = M._malloc(a.length);
  M.HEAPU8.set(a, p);
  return p;
}

//Provides: bls_free
//Requires: caml_failwith
function bls_free(p) {
  var g = globalThis;
  var M = g._BLS12381;
  if (!M) caml_failwith('bls12-381 was not initialized');
  M._free(p);
}

//Provides: wasm_call
//Requires: Ml_Bigarray, MlBytes
//Requires: caml_failwith, caml_ml_bytes_length, caml_array_of_bytes
function wasm_call() {
  var g = globalThis;
  var M = g._BLS12381;
  var f = arguments[0];
  if (!M) caml_failwith('bls12-381 was not initialized');
  if (!M[f]) caml_failwith(f + ' is not implemented');
  var args = Array.prototype.slice.call(arguments, 1);
  // argsc is the array of argument that we will pass to wasm,
  // it will be mutated before the call.
  var argsc = args.slice();
  // argsu is used to handle the case where multiple arguments
  // are physically the same.
  // We don't want to copy the piece of memory multiple time into wasm
  var argsu = new g.Map();
  for (var i = 0; i < args.length; i++) {
    var x = args[i];
    if (typeof x == 'number' || typeof x == 'boolean' || x === null) {
      // Theses primitive types can be passed to wasm
      continue;
    } else if (x instanceof g.Uint8Array) {
      if (argsu.get(x)) {
        argsc[i] = argsu.get(x);
      } else {
        var p = M._malloc(x.length);
        M.HEAPU8.set(x, p);
        argsu.set(x, p);
        argsc[i] = p;
      }
    } else if (x instanceof MlBytes) {
      if (argsu.get(x)) {
        argsc[i] = argsu.get(x);
      } else {
        var a = caml_array_of_bytes(x);
        var p = M._malloc(a.length);
        M.HEAPU8.set(a, p);
        argsu.set(x, p);
        argsc[i] = p;
      }
    } else if (
      x instanceof Array &&
      x.every(function(x) {
        return x instanceof g.Uint8Array;
      })
    ) {
      var ps = new g.Uint32Array(x.length);
      for (var k = 0; k < x.length; k++) {
        if (argsu.get(x[k])) {
          ps[k] = argsu.get(x[k]);
        } else {
          var p = M._malloc(x[k].length);
          M.HEAPU8.set(x[k], p);
          argsu.set(x[k], p);
          ps[k] = p;
        }
      }
      var p = M._malloc(ps.length * 4);
      M.HEAPU32.set(ps, p / 4);
      argsu.set(ps, p);
      argsc[i] = p;
    } else {
      // Other types of arguments are not handled yet
      // Try to report and informative error
      var r = '(';
      for (i = 0; i < args.length; i++) {
        if (i != 0) r += ', ';
        var err = '*ERR*';
        var x = args[i];
        var typeof_x = typeof x;
        // Valid argument type
        if (typeof_x == 'number' || typeof_x == 'boolean') r += typeof_x;
        else if (x instanceof g.Uint8Array) r += 'uint8';
        // Invalid argument type
        else if (x instanceof MlBytes) r += 'bytes';
        else if (x == null) r += err + 'null';
        else if (x == undefined) r += err + 'undefined';
        else r += err + typeof_x;
      }
      r += ')';
      g.console.error(
          'call_wasm: unsupported argument type: ' + f + r,
          new Error()
      );
      caml_failwith(
          'call_wasm: ' + f + ' called with unsupported argument type: ' + r
      );
    }
  }

  // Call into wasm
  var r = M[f].apply(null, argsc);

  // Copy the memory back into the JS world
  var it = argsu.entries();
  for (;;) {
    var e = it.next();
    if (e.done) break;
    var x = e.value[0];
    var p = e.value[1];
    if (x instanceof g.Uint8Array) {
      x.set(new g.Uint8Array(M.HEAPU8.buffer, p, x.length));
      M._free(p);
    } else if (x instanceof g.Uint32Array) {
      M._free(p);
    } else if (x instanceof MlBytes) {
      var a = caml_array_of_bytes(x);
      for (var i = 0; i < a.length; i++) {
        a[i] = M.HEAPU8[p + i];
      }
      M._free(p);
    } else {
      caml_failwith('call_wasm: Impossible');
    }
  }
  return r;
}

//Provides: caml_blst_memcpy
function caml_blst_memcpy(dest, src, size) {
  if (src.length != size) src = src.subarray(0, size);
  dest.set(src, 0);
}