@grain/binaryen.ml 0.35.0 → 0.37.0

binaryen-archive/src/type_builder.mli

@@ -0,0 +1,28 @@
+type t
+
+type struct_field = {
+  type_ : Type.t;
+  packed_type : Packed_type.t;
+  mutable_ : bool;
+}
+
+(* Source: https://github.com/WebAssembly/binaryen/blob/64ba23996a10e229d46e41eb37736a55af87f79a/src/binaryen-c.h#L3618 *)
+type error =
+  | SelfSupertype of int
+  | InvalidSupertype of int
+  | ForwardSupertypeReference of int
+  | ForwardChildReference of int
+
+val make : int -> t
+val grow : t -> int -> unit
+val size : t -> int
+val set_signature_type : t -> int -> Type.t -> Type.t -> unit
+val set_struct_type : t -> int -> struct_field list -> unit
+val set_array_type : t -> int -> Type.t -> Packed_type.t -> bool -> unit
+val get_temp_heap_type : t -> int -> Heap_type.t
+val get_temp_tuple_type : t -> Type.t list -> Type.t
+val get_temp_ref_type : t -> Heap_type.t -> bool -> Type.t
+val set_sub_type : t -> int -> Heap_type.t -> unit
+val set_open : t -> int -> unit
+val create_rec_group : t -> int -> int -> unit
+val build_and_dispose : t -> (Heap_type.t list, error) result

binaryen-archive/test/test.expected

@@ -7,12 +7,16 @@
  (i32.const 0)
 )
 (module
- (type $0 (func (param i32)))
- (type $1 (func (param i32 i32) (result i32)))
- (type $2 (func))
- (type $3 (func (param anyref i32 i32) (result i32)))
- (type $4 (func (param anyref) (result i32)))
- (import "future-wasi" "write" (func $write (type $3) (param anyref i32 i32) (result i32)))
+ (type $List (struct (field $head i31ref) (field $tail (ref null $List))))
+ (type $1 (array (mut i8)))
+ (type $2 (func (param i32)))
+ (type $3 (func (param i32 i32) (result i32)))
+ (type $4 (func))
+ (type $5 (func (param anyref i32 i32) (result i32)))
+ (type $6 (func (param anyref) (result i32)))
+ (type $7 (func (param anyref) (result anyref anyref)))
+ (type $8 (func (result (ref $1) (ref $List))))
+ (import "future-wasi" "write" (func $write (type $5) (param anyref i32 i32) (result i32)))
  (global $max_int64 i64 (i64.const 9223372036854775807))
  (global $max_int64_mut (mut i64) (i64.const 9223372036854775807))
  (global $test_float64_bits f64 (f64.const 1.23))
@@ -21,14 +25,15 @@
  (data $world "world")
  (table $table 1 1 funcref)
  (elem $elem (i32.const 0) $adder)
- (tag $foo (type $0) (param i32))
- (tag $bar (type $0) (param i32))
+ (tag $foo (type $2) (param i32))
+ (tag $bar (type $2) (param i32))
  (export "adder" (func $adder))
  (export "memory" (memory $0))
  (export "hello" (func $hello))
  (export "try" (func $try))
+ (export "gc" (func $gc))
  (start $start)
- (func $adder (type $1) (param $0 i32) (param $1 i32) (result i32)
+ (func $adder (type $3) (param $0 i32) (param $1 i32) (result i32)
   (block $add (result i32)
    (if
     (i32.const 0)
@@ -48,7 +53,7 @@
    )
   )
  )
- (func $start (type $2)
+ (func $start (type $4)
   (block $start
    (memory.init $world
     (i32.const 2048)
@@ -56,7 +61,7 @@
     (i32.const 5)
    )
    (drop
-    (call_indirect $table (type $1)
+    (call_indirect $table (type $3)
      (i32.const 3)
      (i32.const 5)
      (i32.const 0)
@@ -64,14 +69,14 @@
    )
   )
  )
- (func $hello (type $4) (param $0 anyref) (result i32)
+ (func $hello (type $6) (param $0 anyref) (result i32)
   (call $write
    (local.get $0)
    (i32.const 0)
    (i32.const 1)
   )
  )
- (func $try (type $2)
+ (func $try (type $4)
   (block $blk
    (drop
     (try $tc1 (result i32)
@@ -139,27 +144,76 @@
    )
   )
  )
+ (func $gc (type $7) (param $0 anyref) (result anyref anyref)
+  (local $1 (ref $1))
+  (local $2 (ref $List))
+  (block $gc_block (type $8) (result (ref $1) (ref $List))
+   (local.set $1
+    (array.new_fixed $1 2
+     (i32.const 0)
+     (i32.const 255)
+    )
+   )
+   (array.set $1
+    (local.get $1)
+    (i32.const 1)
+    (i32.const 42)
+   )
+   (local.set $2
+    (struct.new $List
+     (ref.cast i31ref
+      (local.get $0)
+     )
+     (struct.new $List
+      (ref.i31
+       (i32.const 1)
+      )
+      (struct.new $List
+       (ref.i31
+        (i32.const 2)
+       )
+       (struct.new $List
+        (ref.i31
+         (i32.const 3)
+        )
+        (ref.null none)
+       )
+      )
+     )
+    )
+   )
+   (tuple.make 2
+    (local.get $1)
+    (local.get $2)
+   )
+  )
+ )
 )
 (module
- (type $0 (func (param i32)))
- (type $1 (func))
- (type $2 (func (param i32 i32) (result i32)))
- (type $3 (func (param anyref i32 i32) (result i32)))
- (type $4 (func (param anyref) (result i32)))
- (import "future-wasi" "write" (func $write (type $3) (param anyref i32 i32) (result i32)))
+ (type $List (struct (field $head i31ref) (field $tail (ref null $List))))
+ (type $1 (array (mut i8)))
+ (type $2 (func (param i32)))
+ (type $3 (func))
+ (type $4 (func (param i32 i32) (result i32)))
+ (type $5 (func (param anyref i32 i32) (result i32)))
+ (type $6 (func (param anyref) (result i32)))
+ (type $7 (func (param anyref) (result anyref anyref)))
+ (type $8 (func (result (ref (exact $1)) (ref (exact $List)))))
+ (import "future-wasi" "write" (func $write (type $5) (param anyref i32 i32) (result i32)))
  (memory $0 1)
  (data $hello (i32.const 0) "hello")
  (data $world "world")
  (table $table 1 1 funcref)
  (elem $elem (i32.const 0) $adder)
- (tag $foo (type $0) (param i32))
- (tag $bar (type $0) (param i32))
+ (tag $foo (type $2) (param i32))
+ (tag $bar (type $2) (param i32))
  (export "adder" (func $adder))
  (export "memory" (memory $0))
  (export "hello" (func $hello))
  (export "try" (func $try))
+ (export "gc" (func $gc))
  (start $start)
- (func $adder (type $2) (param $0 i32) (param $1 i32) (result i32)
+ (func $adder (type $4) (param $0 i32) (param $1 i32) (result i32)
   (i32.add
    (select
     (local.get $0)
@@ -171,7 +225,7 @@
    (local.get $1)
   )
  )
- (func $start (type $1)
+ (func $start (type $3)
   (memory.init $world
    (i32.const 2048)
    (i32.const 0)
@@ -184,14 +238,14 @@
    )
   )
  )
- (func $hello (type $4) (param $0 anyref) (result i32)
+ (func $hello (type $6) (param $0 anyref) (result i32)
   (call $write
    (local.get $0)
    (i32.const 0)
    (i32.const 1)
   )
  )
- (func $try (type $1)
+ (func $try (type $3)
   (drop
    (try (result i32)
     (do
@@ -231,12 +285,53 @@
    )
   )
  )
+ (func $gc (type $7) (param $0 anyref) (result anyref anyref)
+  (local $1 (ref (exact $1)))
+  (array.set $1
+   (local.tee $1
+    (array.new_fixed $1 2
+     (i32.const 0)
+     (i32.const 255)
+    )
+   )
+   (i32.const 1)
+   (i32.const 42)
+  )
+  (tuple.make 2
+   (local.get $1)
+   (struct.new $List
+    (ref.cast i31ref
+     (local.get $0)
+    )
+    (struct.new $List
+     (ref.i31
+      (i32.const 1)
+     )
+     (struct.new $List
+      (ref.i31
+       (i32.const 2)
+      )
+      (struct.new $List
+       (ref.i31
+        (i32.const 3)
+       )
+       (ref.null none)
+      )
+     )
+    )
+   )
+  )
+ )
 )
 (module
+ (type $type_7 (struct (field i31ref) (field (ref null $type_7))))
+ (type $type_6 (array (mut i8)))
  (type $type_3 (func))
  (type $type_1 (func (param anyref i32 i32) (result i32)))
  (type $type_2 (func (param i32 i32) (result i32)))
  (type $type_4 (func (param anyref) (result i32)))
+ (type $type_5 (func (param anyref) (result anyref anyref)))
+ (type $type_8 (func (result anyref anyref)))
  (import "future-wasi" "write" (func $fimport$0 (type $type_1) (param anyref i32 i32) (result i32)))
  (memory $0 1)
  (data $0 (i32.const 0) "hello")
@@ -247,6 +342,7 @@
  (export "memory" (memory $0))
  (export "hello" (func $2))
  (export "try" (func $3))
+ (export "gc" (func $4))
  (start $1)
  (func $0 (type $type_2) (param $0 i32) (param $1 i32) (result i32)
   (i32.add
@@ -286,12 +382,53 @@
   )
   (unreachable)
  )
+ (func $4 (type $type_5) (param $0 anyref) (result anyref anyref)
+  (local $1 (ref (exact $type_6)))
+  (array.set $type_6
+   (local.tee $1
+    (array.new_fixed $type_6 2
+     (i32.const 0)
+     (i32.const 255)
+    )
+   )
+   (i32.const 1)
+   (i32.const 42)
+  )
+  (tuple.make 2
+   (local.get $1)
+   (struct.new $type_7
+    (ref.cast i31ref
+     (local.get $0)
+    )
+    (struct.new $type_7
+     (ref.i31
+      (i32.const 1)
+     )
+     (struct.new $type_7
+      (ref.i31
+       (i32.const 2)
+      )
+      (struct.new $type_7
+       (ref.i31
+        (i32.const 3)
+       )
+       (ref.null none)
+      )
+     )
+    )
+   )
+  )
+ )
 )
 (module
+ (type $type_7 (struct (field i31ref) (field (ref null $type_7))))
+ (type $type_6 (array (mut i8)))
  (type $type_3 (func))
  (type $type_1 (func (param anyref i32 i32) (result i32)))
  (type $type_2 (func (param i32 i32) (result i32)))
  (type $type_4 (func (param anyref) (result i32)))
+ (type $type_5 (func (param anyref) (result anyref anyref)))
+ (type $type_8 (func (result anyref anyref)))
  (import "future-wasi" "write" (func $fimport$0 (type $type_1) (param anyref i32 i32) (result i32)))
  (memory $0 1)
  (data $0 (i32.const 0) "hello")
@@ -302,6 +439,7 @@
  (export "memory" (memory $0))
  (export "hello" (func $2))
  (export "try" (func $3))
+ (export "gc" (func $4))
  (start $1)
  (func $0 (type $type_2) (param $0 i32) (param $1 i32) (result i32)
   local.get $0
@@ -331,4 +469,29 @@
  (func $3 (type $type_3)
   unreachable
  )
+ (func $4 (type $type_5) (param $0 anyref) (result anyref anyref)
+  (local $1 (ref (exact $type_6)))
+  i32.const 0
+  i32.const 255
+  array.new_fixed $type_6 2
+  local.tee $1
+  i32.const 1
+  i32.const 42
+  array.set $type_6
+  local.get $1
+  local.get $0
+  ref.cast i31ref
+  i32.const 1
+  ref.i31
+  i32.const 2
+  ref.i31
+  i32.const 3
+  ref.i31
+  ref.null none
+  struct.new $type_7
+  struct.new $type_7
+  struct.new $type_7
+  struct.new $type_7
+  tuple.make 2
+ )
 )

binaryen-archive/test/test.ml

@@ -171,13 +171,19 @@ let start =
 let _ = Export.add_function_export wasm_mod "adder" "adder"
 let _ = Table.add_table wasm_mod "table" 1 1 Type.funcref
 
-(* TODO(#240): Re-enable after type-builder api is merged *)
-(* let funcref_expr1 = Expression.Ref.func wasm_mod "adder" (Heap_type.func ())
+let adder_type =
+  let builder = Type_builder.make 1 in
+  Type_builder.set_signature_type builder 0 (params ()) results;
+  match Type_builder.build_and_dispose builder with
+  | Ok [ ty ] -> ty
+  | _ -> failwith "failed to build type"
+
+let funcref_expr1 = Expression.Ref.func wasm_mod "adder" adder_type
 
 let _ =
   Expression.Table.set wasm_mod "table"
     (Expression.Const.make wasm_mod (Literal.int32 0l))
-    funcref_expr1 *)
+    funcref_expr1
 
 let funcref_expr2 =
   Expression.Table.get wasm_mod "table"
@@ -248,12 +254,28 @@ let _ = Memory.set_memory max_memory_wasm_mod 1 2 "memory" [] false false "0"
 let _ = assert (Memory.has_max max_memory_wasm_mod "0" = true)
 let _ = assert (Memory.get_max max_memory_wasm_mod "0" = 2)
 
+(* Memory.get_segment_byte_offset Passive *)
+let _ = assert (Memory.get_segment_byte_offset wasm_mod "world" = None)
+
 let _ =
   assert (
     Bytes.equal
       (Memory.get_segment_data wasm_mod "world")
       (Bytes.of_string "world"))
 
+(* Call_ref *)
+let thunk_type =
+  let builder = Type_builder.make 1 in
+  Type_builder.set_signature_type builder 0 Type.none Type.none;
+  match Type_builder.build_and_dispose builder with
+  | Ok [ ty ] -> ty
+  | _ -> failwith "failed to build type"
+
+let _ =
+  Expression.Call_ref.make wasm_mod
+    (Expression.Ref.func wasm_mod "start" thunk_type)
+    [] Type.none
+
 let _ = Tag.add_tag wasm_mod "foo" Type.int32 Type.none
 let _ = Tag.add_tag wasm_mod "bar" Type.int32 Type.none
 
@@ -365,6 +387,111 @@ let _ = Export.add_function_export wasm_mod "hello" "hello"
 let _ = Export.add_function_export wasm_mod "try" "try"
 let _ = Module.validate wasm_mod
 
+(* Create a function that does gc *)
+let _ =
+  let array_u8_type =
+    let builder = Type_builder.make 1 in
+    Type_builder.set_array_type builder 0 Type.int32 Packed_type.int8 true;
+    match Type_builder.build_and_dispose builder with
+    | Ok [ ty ] -> ty
+    | _ -> failwith "failed to make array type"
+  in
+  let list_type =
+    let builder = Type_builder.make 1 in
+    let temp_heap_type = Type_builder.get_temp_heap_type builder 0 in
+    let temp_ref_type =
+      Type_builder.get_temp_ref_type builder temp_heap_type true
+    in
+    Type_builder.set_struct_type builder 0
+      [
+        Type_builder.
+          {
+            type_ = Type.i31ref;
+            packed_type = Packed_type.not_packed;
+            mutable_ = false;
+          };
+        Type_builder.
+          {
+            type_ = temp_ref_type;
+            packed_type = Packed_type.not_packed;
+            mutable_ = false;
+          };
+      ];
+    match Type_builder.build_and_dispose builder with
+    | Ok [ ty ] -> ty
+    | _ -> failwith "failed to make list type"
+  in
+  let i32 v = Expression.Const.make wasm_mod (Literal.int32 v) in
+  let i31 v = Expression.I31.make wasm_mod (i32 v) in
+  let cons first rest =
+    Expression.Struct.new_ wasm_mod (Some [ first; rest ]) list_type
+  in
+  let empty () =
+    Expression.Ref.null wasm_mod (Type.from_heap_type list_type true)
+  in
+  Function.add_function wasm_mod "gc" Type.anyref
+    (Type.create [| Type.anyref; Type.anyref |])
+    [|
+      Type.from_heap_type array_u8_type false;
+      Type.from_heap_type list_type false;
+    |]
+    (Expression.Block.make wasm_mod "gc_block"
+       [
+         Expression.Local_set.make wasm_mod 1
+           (Expression.Array.new_fixed wasm_mod array_u8_type
+              [ i32 0l; i32 255l ]);
+         Expression.Array.set wasm_mod
+           (Expression.Local_get.make wasm_mod 1
+              (Type.from_heap_type array_u8_type false))
+           (i32 1l) (i32 42l);
+         Expression.Local_set.make wasm_mod 2
+           (cons
+              (Expression.Ref.cast wasm_mod
+                 (Expression.Local_get.make wasm_mod 0 Type.anyref)
+                 Type.i31ref)
+              (cons (i31 1l) (cons (i31 2l) (cons (i31 3l) (empty ())))));
+         Expression.Tuple_make.make wasm_mod
+           [
+             Expression.Local_get.make wasm_mod 1
+               (Type.from_heap_type array_u8_type false);
+             Expression.Local_get.make wasm_mod 2
+               (Type.from_heap_type list_type false);
+           ];
+       ])
+
+let _ = Export.add_function_export wasm_mod "gc" "gc"
+let _ = assert (Module.validate wasm_mod == 1)
+
+(* Test Heap_type.set_type_name and Heap_type.set_field_name *)
+let list_type =
+  let builder = Type_builder.make 1 in
+  let temp_heap_type = Type_builder.get_temp_heap_type builder 0 in
+  let temp_ref_type =
+    Type_builder.get_temp_ref_type builder temp_heap_type true
+  in
+  Type_builder.set_struct_type builder 0
+    [
+      Type_builder.
+        {
+          type_ = Type.i31ref;
+          packed_type = Packed_type.not_packed;
+          mutable_ = false;
+        };
+      Type_builder.
+        {
+          type_ = temp_ref_type;
+          packed_type = Packed_type.not_packed;
+          mutable_ = false;
+        };
+    ];
+  match Type_builder.build_and_dispose builder with
+  | Ok [ ty ] -> ty
+  | _ -> failwith "failed to make list type"
+
+let _ = Heap_type.set_type_name wasm_mod list_type "List"
+let _ = Heap_type.set_field_name wasm_mod list_type 0 "head"
+let _ = Heap_type.set_field_name wasm_mod list_type 1 "tail"
+
 (* Shouldn't actually do anything since we aren't doing function renames *)
 let _ = Module.update_maps wasm_mod
 
@@ -437,7 +564,7 @@ let _ =
       Module.Feature.all;
     ]
 
-let _ = Module.validate new_mod
+let _ = assert (Module.validate new_mod == 1)
 let _ = Module.print new_mod
 let _ = Module.print_stack_ir new_mod
 

binaryen-archive/esy.lock/opam/base-bytes.base/opam

@@ -1,10 +0,0 @@
-opam-version: "2.0"
-maintainer: " "
-authors: " "
-homepage: " "
-depends: [
-  "ocaml" {>= "4.02.0"}
-  "ocamlfind" {>= "1.5.3"}
-]
-synopsis: "Bytes library distributed with the OCaml compiler"
-x-maintained: true

binaryen-archive/esy.lock/opam/fs-io.3.21.1/opam

@@ -1,41 +0,0 @@
-opam-version: "2.0"
-synopsis: "File System Operations"
-description: "Misc. Collection of File System Operations"
-maintainer: ["Jane Street Group, LLC <opensource@janestreet.com>"]
-authors: ["Jane Street Group, LLC <opensource@janestreet.com>"]
-license: "MIT"
-homepage: "https://github.com/ocaml/dune"
-doc: "https://dune.readthedocs.io/"
-bug-reports: "https://github.com/ocaml/dune/issues"
-depends: [
-  "dune" {>= "3.21"}
-  "base-unix"
-  "ocaml" {>= "4.08"}
-  "odoc" {with-doc}
-]
-dev-repo: "git+https://github.com/ocaml/dune.git"
-x-maintenance-intent: ["none"]
-build: [
-  ["dune" "subst"] {dev}
-  ["rm" "-rf" "vendor/csexp"]
-  ["rm" "-rf" "vendor/pp"]
-  [
-    "dune"
-    "build"
-    "-p"
-    name
-    "-j"
-    jobs
-    "@install"
-    "@doc" {with-doc}
-  ]
-]
-url {
-  src:
-    "https://github.com/ocaml/dune/releases/download/3.21.1/dune-3.21.1.tbz"
-  checksum: [
-    "sha256=84f7a82c6d80a7124f3847e9a489e80cfbeafb7bed3573ac01286ef56fd08d94"
-    "sha512=d9fa44e24036d2593adfe59e52e0ad64f3e7e973d23f84af57fc79e38fa210630b0cb55590f314d6ef455333b96a8e0ce188c2720eaae44576222541ba78efb3"
-  ]
-}
-x-commit-hash: "0b5863d9be475453b3cc2bd321fde222af2544d4"

binaryen-archive/esy.lock/opam/js_of_ocaml-compiler.6.2.0/opam

@@ -1,56 +0,0 @@
-opam-version: "2.0"
-synopsis: "Compiler from OCaml bytecode to JavaScript"
-description:
-  "Js_of_ocaml is a compiler from OCaml bytecode to JavaScript. It makes it possible to run pure OCaml programs in JavaScript environment like browsers and Node.js"
-maintainer: ["Ocsigen team <dev@ocsigen.org>"]
-authors: ["Ocsigen team <dev@ocsigen.org>"]
-license: [
-  "GPL-2.0-or-later" "LGPL-2.1-or-later WITH OCaml-LGPL-linking-exception"
-]
-homepage: "https://ocsigen.org/js_of_ocaml/latest/manual/overview"
-doc: "https://ocsigen.org/js_of_ocaml/latest/manual/overview"
-bug-reports: "https://github.com/ocsigen/js_of_ocaml/issues"
-depends: [
-  "dune" {>= "3.19"}
-  "ocaml" {>= "4.13" & < "5.5"}
-  "num" {with-test}
-  "ppx_expect" {>= "v0.16.1" & with-test}
-  "ppxlib" {>= "0.35"}
-  "re" {with-test}
-  "cmdliner" {>= "1.1.0"}
-  "sedlex" {>= "3.3"}
-  "qcheck" {with-test}
-  "menhir"
-  "menhirLib"
-  "menhirSdk"
-  "yojson" {>= "2.1"}
-  "odoc" {with-doc}
-]
-depopts: ["ocamlfind"]
-conflicts: [
-  "ocamlfind" {< "1.5.1"}
-  "js_of_ocaml" {< "3.0"}
-]
-dev-repo: "git+https://github.com/ocsigen/js_of_ocaml.git"
-x-maintenance-intent: ["(latest)"]
-build: [
-  [
-    "dune"
-    "build"
-    "-p"
-    name
-    "-j"
-    jobs
-    "@install"
-    "@doc" {with-doc}
-  ]
-]
-url {
-  src:
-    "https://github.com/ocsigen/js_of_ocaml/releases/download/6.2.0/js_of_ocaml-6.2.0.tbz"
-  checksum: [
-    "sha256=7cc641778d1b172a352a88333ee0e8c621365a0acfcd9b87e38bfddb8dd2a5da"
-    "sha512=da50c79e1ad667df22abe03d0928ee135729c90cf09279e3c4854aec66557e8600890ca58f550529de1b1a44698720890b97528df167fd9e10cce24c71e763e6"
-  ]
-}
-x-commit-hash: "938c18c46b78836119483d9cc9ce25ffdc44b718"

binaryen-archive/esy.lock/opam/stdlib-shims.0.3.0/opam

@@ -1,31 +0,0 @@
-opam-version: "2.0"
-maintainer: "The stdlib-shims programmers"
-authors: "The stdlib-shims programmers"
-homepage: "https://github.com/ocaml/stdlib-shims"
-doc: "https://ocaml.github.io/stdlib-shims/"
-dev-repo: "git+https://github.com/ocaml/stdlib-shims.git"
-bug-reports: "https://github.com/ocaml/stdlib-shims/issues"
-tags: ["stdlib" "compatibility" "org:ocaml"]
-license: ["LGPL-2.1-only WITH OCaml-LGPL-linking-exception"]
-depends: [
-  "dune"
-  "ocaml" {>= "4.02.3"}
-]
-build: [ "dune" "build" "-p" name "-j" jobs ]
-synopsis: "Backport some of the new stdlib features to older compiler"
-description: """
-Backport some of the new stdlib features to older compiler,
-such as the Stdlib module.
-
-This allows projects that require compatibility with older compiler to
-use these new features in their code.
-"""
-x-commit-hash: "fb6815e5d745f07fd567c11671149de6ef2e74c8"
-url {
-  src:
-    "https://github.com/ocaml/stdlib-shims/releases/download/0.3.0/stdlib-shims-0.3.0.tbz"
-  checksum: [
-    "sha256=babf72d3917b86f707885f0c5528e36c63fccb698f4b46cf2bab5c7ccdd6d84a"
-    "sha512=1151d7edc8923516e9a36995a3f8938d323aaade759ad349ed15d6d8501db61ffbe63277e97c4d86149cf371306ac23df0f581ec7e02611f58335126e1870980"
-  ]
-}